diff --git a/room/compiler/src/main/kotlin/com/android/support/room/writer/DatabaseWriter.kt b/room/compiler/src/main/kotlin/com/android/support/room/writer/DatabaseWriter.kt
index 69ca7f2..6a02f07 100644
--- a/room/compiler/src/main/kotlin/com/android/support/room/writer/DatabaseWriter.kt
+++ b/room/compiler/src/main/kotlin/com/android/support/room/writer/DatabaseWriter.kt
@@ -25,7 +25,6 @@
 import com.android.support.room.vo.DaoMethod
 import com.android.support.room.vo.Database
 import com.google.auto.common.MoreElements
-import com.google.auto.common.MoreTypes
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.ParameterSpec
@@ -45,7 +44,6 @@
         builder.apply {
             addModifiers(PUBLIC)
             superclass(database.typeName)
-            addMethod(createConstructor())
             addMethod(createCreateOpenHelper())
         }
         addDaoImpls(builder)
@@ -57,7 +55,7 @@
         builder.apply {
             database.daoMethods.forEach { method ->
                 val name = method.dao.typeName.simpleName().decapitalize().stripNonJava()
-                var fieldName = scope.getTmpVar("_$name")
+                val fieldName = scope.getTmpVar("_$name")
                 val field = FieldSpec.builder(method.dao.typeName, fieldName,
                         PRIVATE, VOLATILE).build()
                 addField(field)
@@ -85,16 +83,6 @@
         }.build()
     }
 
-    private fun createConstructor(): MethodSpec {
-        return MethodSpec.constructorBuilder().apply {
-            addModifiers(Modifier.PUBLIC)
-            val configParam = ParameterSpec.builder(RoomTypeNames.ROOM_DB_CONFIG,
-                    "configuration").build()
-            addParameter(configParam)
-            addStatement("super($N)", configParam)
-        }.build()
-    }
-
     private fun createCreateOpenHelper() : MethodSpec {
         val scope = CodeGenScope()
         return MethodSpec.methodBuilder("createOpenHelper").apply {
diff --git a/room/compiler/src/test/data/databasewriter/input/ComplexDatabase.java b/room/compiler/src/test/data/databasewriter/input/ComplexDatabase.java
index c71f3ae..eba60cc 100644
--- a/room/compiler/src/test/data/databasewriter/input/ComplexDatabase.java
+++ b/room/compiler/src/test/data/databasewriter/input/ComplexDatabase.java
@@ -19,8 +19,5 @@
 import java.util.List;
 @Database(entities = {User.class})
 abstract class ComplexDatabase extends RoomDatabase {
-    public ComplexDatabase(DatabaseConfiguration configuration) {
-        super(configuration);
-    }
     abstract ComplexDao getComplexDao();
 }
diff --git a/room/compiler/src/test/data/databasewriter/output/ComplexDatabase.java b/room/compiler/src/test/data/databasewriter/output/ComplexDatabase.java
index 19060f8..9961db4 100644
--- a/room/compiler/src/test/data/databasewriter/output/ComplexDatabase.java
+++ b/room/compiler/src/test/data/databasewriter/output/ComplexDatabase.java
@@ -10,10 +10,6 @@
 public class ComplexDatabase_Impl extends ComplexDatabase {
     private volatile ComplexDao _complexDao;
 
-    public ComplexDatabase_Impl(DatabaseConfiguration configuration) {
-        super(configuration);
-    }
-
     protected SupportSQLiteOpenHelper createOpenHelper(DatabaseConfiguration configuration) {
         final SupportSQLiteOpenHelper.Callback _openCallback = new SupportSQLiteOpenHelper.Callback() {
             public void onCreate(SupportSQLiteDatabase _db) {
diff --git a/room/compiler/src/test/kotlin/com/android/support/room/processor/DatabaseProcessorTest.kt b/room/compiler/src/test/kotlin/com/android/support/room/processor/DatabaseProcessorTest.kt
index 0b4d148..3ec804b 100644
--- a/room/compiler/src/test/kotlin/com/android/support/room/processor/DatabaseProcessorTest.kt
+++ b/room/compiler/src/test/kotlin/com/android/support/room/processor/DatabaseProcessorTest.kt
@@ -85,9 +85,6 @@
         singleDb("""
             @Database(entities = {User.class})
             public abstract class MyDb extends RoomDatabase {
-                public MyDb(DatabaseConfiguration config) {
-                    super(config);
-                }
                 abstract UserDao userDao();
             }
             """, USER, USER_DAO) { db, invocation ->
@@ -101,9 +98,6 @@
         singleDb("""
             @Database(entities = {User.class, Book.class})
             public abstract class MyDb extends RoomDatabase {
-                public MyDb(DatabaseConfiguration config) {
-                    super(config);
-                }
                 abstract UserDao userDao();
                 abstract BookDao bookDao();
             }
@@ -132,9 +126,6 @@
                 """
                 @Database(entities = {Book.class})
                 public abstract class MyDb extends RoomDatabase {
-                    public MyDb(DatabaseConfiguration config) {
-                        super(config);
-                    }
                     abstract BookDao bookDao();
                 }
                 """, BOOK, JavaFileObjects.forSourceString("foo.bar.BookDao",
@@ -159,9 +150,6 @@
         singleDb("""
                 @Database(entities = {User.class, AnotherClass.class})
                 public abstract class MyDb extends RoomDatabase {
-                    public MyDb(DatabaseConfiguration config) {
-                        super(config);
-                    }
                     abstract UserDao userDao();
                 }
                 """, USER, USER_DAO, JavaFileObjects.forSourceString("foo.bar.AnotherClass",
diff --git a/room/compiler/src/test/kotlin/com/android/support/room/writer/SQLiteOpenHelperWriterTest.kt b/room/compiler/src/test/kotlin/com/android/support/room/writer/SQLiteOpenHelperWriterTest.kt
index e6cd006..a603301 100644
--- a/room/compiler/src/test/kotlin/com/android/support/room/writer/SQLiteOpenHelperWriterTest.kt
+++ b/room/compiler/src/test/kotlin/com/android/support/room/writer/SQLiteOpenHelperWriterTest.kt
@@ -46,9 +46,6 @@
             import com.android.support.room.*;
             @Database(entities = {MyEntity.class})
             abstract public class MyDatabase extends RoomDatabase {
-                public MyDatabase(DatabaseConfiguration configuration) {
-                    super(configuration);
-                }
             }
             """
     }
diff --git a/room/integration-tests/testapp/build.gradle b/room/integration-tests/testapp/build.gradle
index a31bd1a..678418c 100644
--- a/room/integration-tests/testapp/build.gradle
+++ b/room/integration-tests/testapp/build.gradle
@@ -55,5 +55,4 @@
 }
 
 createAndroidCheckstyle(project)
-
 tasks['check'].dependsOn(tasks['connectedCheck'])
diff --git a/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/TestDatabase.java b/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/TestDatabase.java
index 58b86ba..5599973 100644
--- a/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/TestDatabase.java
+++ b/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/TestDatabase.java
@@ -17,22 +17,11 @@
 package com.android.support.room.integration.testapp;
 
 import com.android.support.room.Database;
-import com.android.support.room.DatabaseConfiguration;
 import com.android.support.room.RoomDatabase;
 import com.android.support.room.integration.testapp.dao.UserDao;
 import com.android.support.room.integration.testapp.vo.User;
 
 @Database(entities = User.class)
 public abstract class TestDatabase extends RoomDatabase {
-    /**
-     * Creates a RoomDatabase with the given configuration.
-     *
-     * @param configuration The configuration to setup the database.
-     */
-    @SuppressWarnings("WeakerAccess")
-    public TestDatabase(DatabaseConfiguration configuration) {
-        super(configuration);
-    }
-
     public abstract UserDao getUserDao();
 }
diff --git a/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/test/SimpleEntityReadWriteTest.java b/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/test/SimpleEntityReadWriteTest.java
index 2d84851..e36c3ca 100644
--- a/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/test/SimpleEntityReadWriteTest.java
+++ b/room/integration-tests/testapp/src/androidTest/java/com/android/support/room/integration/testapp/test/SimpleEntityReadWriteTest.java
@@ -22,9 +22,8 @@
 import android.support.test.filters.SmallTest;
 import android.support.test.runner.AndroidJUnit4;
 
-import com.android.support.room.DatabaseConfiguration;
+import com.android.support.room.Room;
 import com.android.support.room.integration.testapp.TestDatabase;
-import com.android.support.room.integration.testapp.TestDatabase_Impl;
 import com.android.support.room.integration.testapp.vo.User;
 
 import junit.framework.AssertionFailedError;
@@ -39,12 +38,11 @@
 @SmallTest
 @RunWith(AndroidJUnit4.class)
 public class SimpleEntityReadWriteTest {
-    TestDatabase mDb;
+    private TestDatabase mDb;
     @Before
     public void createDb() {
         Context context = InstrumentationRegistry.getTargetContext();
-        DatabaseConfiguration configuration = new DatabaseConfiguration.Builder(context).build();
-        mDb = new TestDatabase_Impl(configuration);
+        mDb = Room.inMemoryDatabaseBuilder(context, TestDatabase.class).build();
     }
     @Test
     public void writeUserAndReadInList() throws Exception {
diff --git a/room/runtime/src/main/java/com/android/support/room/DatabaseConfiguration.java b/room/runtime/src/main/java/com/android/support/room/DatabaseConfiguration.java
index 7a6431a..7bac243 100644
--- a/room/runtime/src/main/java/com/android/support/room/DatabaseConfiguration.java
+++ b/room/runtime/src/main/java/com/android/support/room/DatabaseConfiguration.java
@@ -19,7 +19,6 @@
 import android.content.Context;
 
 import com.android.support.db.SupportSQLiteOpenHelper;
-import com.android.support.db.framework.FrameworkSQLiteOpenHelperFactory;
 
 /**
  * Configuration class for {@link RoomDatabase}.
@@ -28,89 +27,28 @@
     /**
      * The factory to use to access the database.
      */
+    @SuppressWarnings("WeakerAccess")
     public final SupportSQLiteOpenHelper.Factory sqliteOpenHelperFactory;
     /**
      * The context to you.
      */
+    @SuppressWarnings("WeakerAccess")
     public final Context context;
     /**
      * The name of the database or null if it is in memory.
      */
+    @SuppressWarnings("WeakerAccess")
     public final String name;
     /**
      * The version of the database.
      */
     public final int version;
 
-    private DatabaseConfiguration(Context context, String name, int version,
+    DatabaseConfiguration(Context context, String name, int version,
                                   SupportSQLiteOpenHelper.Factory sqliteOpenHelperFactory) {
         this.sqliteOpenHelperFactory = sqliteOpenHelperFactory;
         this.context = context;
         this.name = name;
         this.version = version;
     }
-
-    /**
-     * Builder for the RoomDatabase configuration.
-     */
-    public static class Builder {
-        SupportSQLiteOpenHelper.Factory mFactory;
-        Context mContext;
-        String mName;
-        int mVersion = 1;
-
-        /**
-         * Sets the database factory. If not set, it defaults to
-         * {@link FrameworkSQLiteOpenHelperFactory}.
-         *
-         * @param factory The factory to use to access the database.
-         *
-         * @return this
-         */
-        public Builder withOpenHelperFactory(SupportSQLiteOpenHelper.Factory factory) {
-            mFactory = factory;
-            return this;
-        }
-
-        /**
-         * @param name The name of the database.
-         * @return this
-         */
-        public Builder withName(String name) {
-            mName = name;
-            return this;
-        }
-
-        /**
-         * Version of the database, defaults to 1.
-         * @param version The database version to use
-         * @return this
-         */
-        public Builder withVersion(int version) {
-            mVersion = version;
-            return this;
-        }
-
-        /**
-         * Creates a Configuration builder with the given context.
-         * Most of the time, this should be an application context.
-         *
-         * @param context The context to use for the database.
-         */
-        public Builder(Context context) {
-            mContext = context;
-        }
-
-        /**
-         * Creates the {@link RoomDatabase.Configuration} object for the database.
-         *
-         * @return Configuration that can be used to create the RoomDatabase.
-         */
-        public DatabaseConfiguration build() {
-            if (mFactory == null) {
-                mFactory = new FrameworkSQLiteOpenHelperFactory();
-            }
-            return new DatabaseConfiguration(mContext, mName, mVersion, mFactory);
-        }
-    }
 }
diff --git a/room/runtime/src/main/java/com/android/support/room/Room.java b/room/runtime/src/main/java/com/android/support/room/Room.java
index a7425b1..13d80c2 100644
--- a/room/runtime/src/main/java/com/android/support/room/Room.java
+++ b/room/runtime/src/main/java/com/android/support/room/Room.java
@@ -16,7 +16,8 @@
 
 package com.android.support.room;
 
-import android.support.annotation.Nullable;
+import android.content.Context;
+import android.support.annotation.NonNull;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -26,7 +27,47 @@
  */
 @SuppressWarnings("unused")
 public class Room {
-    private static Map<Class, CursorConverter> sCache = new HashMap<>();
+    private static final String CURSOR_CONV_SUFFIX = "_CursorConverter";
+    private static Map<Class, CursorConverter> sCursorConverterCache = new HashMap<>();
+
+    /**
+     * Creates a RoomDatabase.Builder for a persistent database. Once a database is built, you
+     * should keep a reference to it and re-use.
+     *
+     * @param context The context for the database. This is usually the Application context.
+     * @param klass The abstract class which is annotated with {@link Database} and extends
+     * {@link RoomDatabase}.
+     * @param name The name of the database file.
+     * @param <T> The type of the database class.
+     * @return A {@code RoomDatabaseBuilder<T>} which you can use to create the database.
+     */
+    @SuppressWarnings("WeakerAccess")
+    public static <T extends RoomDatabase> RoomDatabase.Builder<T> databaseBuilder(
+            @NonNull Context context, @NonNull Class<T> klass, @NonNull String name) {
+        //noinspection ConstantConditions
+        if (name == null || name.trim().length() == 0) {
+            throw new IllegalArgumentException("Cannot create a database with null or empty name."
+                    + " If you are trying to create an in memory database, use Room"
+                    + ".inMemoryDatabaseBuilder");
+        }
+        return new RoomDatabase.Builder<>(context, klass, name);
+    }
+
+    /**
+     * Creates a RoomDatabase.Builder for an in memory database. Information stored in an in memory
+     * database disappears when the process is killed.
+     * Once a database is built, you should keep a reference to it and re-use.
+     *
+     * @param context The context for the database. This is usually the Application context.
+     * @param klass The abstract class which is annotated with {@link Database} and extends
+     * {@link RoomDatabase}.
+     * @param <T> The type of the database class.
+     * @return A {@code RoomDatabaseBuilder<T>} which you can use to create the database.
+     */
+    public static <T extends RoomDatabase> RoomDatabase.Builder<T> inMemoryDatabaseBuilder(
+            @NonNull Context context, @NonNull Class<T> klass) {
+        return new RoomDatabase.Builder<>(context, klass, null);
+    }
 
     /**
      * Returns the CursorConverter for the given type.
@@ -36,40 +77,33 @@
      * @return A CursorConverter that can create an instance of the given klass from a Cursor.
      */
     public static <T> CursorConverter<T> getConverter(Class<T> klass) {
-        CursorConverter existing = sCache.get(klass);
+        CursorConverter existing = sCursorConverterCache.get(klass);
         if (existing != null) {
             //noinspection unchecked
             return existing;
         }
-        CursorConverter<T> generated = getGeneratedCursorConverter(klass);
-        sCache.put(klass, generated);
+        CursorConverter<T> generated = getGeneratedImplementation(klass, CURSOR_CONV_SUFFIX);
+        sCursorConverterCache.put(klass, generated);
         return generated;
     }
 
-    @Nullable
-    private static <T> CursorConverter<T> getGeneratedCursorConverter(Class<T> klass) {
-        final String fullPackage = klass.getPackage().getName();
-        final String converterName = getConverterName(klass.getSimpleName());
+    @NonNull
+    static <T, C> T getGeneratedImplementation(Class<C> klass, String suffix) {
         //noinspection TryWithIdenticalCatches
         try {
             @SuppressWarnings("unchecked")
-            final Class<? extends CursorConverter<T>> aClass =
-                    (Class<? extends CursorConverter<T>>) Class.forName(
-                            fullPackage + "." + converterName);
+            final Class<T> aClass =
+                    (Class<T>) Class.forName(klass.getName() + suffix);
             return aClass.newInstance();
         } catch (ClassNotFoundException e) {
-            throw new RuntimeException("cannot find cursor converter for "
+            throw new RuntimeException("cannot find implementation for "
                     + klass.getCanonicalName());
         } catch (IllegalAccessException e) {
-            throw new RuntimeException("Cannot access cursor converter constructor"
+            throw new RuntimeException("Cannot access the constructor"
                     + klass.getCanonicalName());
         } catch (InstantiationException e) {
-            throw new RuntimeException("Failed to create an instance of the cursor converter"
+            throw new RuntimeException("Failed to create an instance of "
                     + klass.getCanonicalName());
         }
     }
-
-    private static String getConverterName(String className) {
-        return className.replace(".", "_") + "_CursorConverter";
-    }
 }
diff --git a/room/runtime/src/main/java/com/android/support/room/RoomDatabase.java b/room/runtime/src/main/java/com/android/support/room/RoomDatabase.java
index 83af0aa..8030adc 100644
--- a/room/runtime/src/main/java/com/android/support/room/RoomDatabase.java
+++ b/room/runtime/src/main/java/com/android/support/room/RoomDatabase.java
@@ -16,26 +16,43 @@
 
 package com.android.support.room;
 
+import android.content.Context;
 import android.database.Cursor;
+import android.support.annotation.CallSuper;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
 import com.android.support.db.SupportSQLiteDatabase;
 import com.android.support.db.SupportSQLiteOpenHelper;
 import com.android.support.db.SupportSQLiteStatement;
+import com.android.support.db.framework.FrameworkSQLiteOpenHelperFactory;
 
 /**
  * Base class for all Room databases.
  */
 @SuppressWarnings({"unused", "WeakerAccess"})
 public abstract class RoomDatabase {
+    private static final String DB_IMPL_SUFFIX = "_Impl";
     private volatile SupportSQLiteDatabase mDatabase;
-    private final SupportSQLiteOpenHelper mOpenHelper;
+    private SupportSQLiteOpenHelper mOpenHelper;
 
     /**
-     * Creates a RoomDatabase with the given configuration.
-     *
-     * @param configuration The configuration to setup the database.
+     * Creates a RoomDatabase.
+     * <p>
+     * You cannot create an instance of a database, instead, you should acquire it via
+     * {@link Room#databaseBuilder(Context, Class, String)} or
+     * {@link Room#inMemoryDatabaseBuilder(Context, Class)}.
      */
-    public RoomDatabase(DatabaseConfiguration configuration) {
+    public RoomDatabase() {
+    }
+
+    /**
+     * Called by {@link Room} when it is initialized.
+     *
+     * @param configuration The database configuration.
+     */
+    @CallSuper
+    public void init(DatabaseConfiguration configuration) {
         mOpenHelper = createOpenHelper(configuration);
     }
 
@@ -54,7 +71,6 @@
      * Note that this method is called when the RoomDatabase is initialized.
      *
      * @param config The configuration of the Room database.
-     *
      * @return A new SupportSQLiteOpenHelper to be used while connecting to the database.
      */
     protected abstract SupportSQLiteOpenHelper createOpenHelper(DatabaseConfiguration config);
@@ -62,12 +78,12 @@
     // Below, there are wrapper methods for SupportSQLiteDatabase. This helps us track which
     // methods we are using and also helps unit tests to mock this class without mocking
     // all sqlite database methods.
+
     /**
      * Wrapper for {@link SupportSQLiteDatabase#rawQuery(String, String[])}.
      *
      * @param sql Sql query to run.
      * @param selectionArgs Selection arguments.
-     *
      * @return Result of the query.
      */
     public Cursor query(String sql, String[] selectionArgs) {
@@ -78,7 +94,6 @@
      * Wrapper for {@link SupportSQLiteDatabase#compileStatement(String)}.
      *
      * @param sql The query to compile.
-     *
      * @return The compiled query.
      */
     public SupportSQLiteStatement compileStatement(String sql) {
@@ -105,4 +120,74 @@
     public void setTransactionSuccessful() {
         mOpenHelper.getWritableDatabase().setTransactionSuccessful();
     }
+
+    /**
+     * Builder for RoomDatabase.
+     *
+     * @param <T> The type of the abstract database class.
+     */
+    @SuppressWarnings("unused")
+    public static class Builder<T extends RoomDatabase> {
+        private final Class<T> mDatabaseClass;
+        private final String mName;
+        private final Context mContext;
+
+        private SupportSQLiteOpenHelper.Factory mFactory;
+        private int mVersion = 1;
+        private boolean mInMemory;
+
+        Builder(@NonNull Context context, @NonNull Class<T> klass, @Nullable String name) {
+            mContext = context;
+            mDatabaseClass = klass;
+            mName = name;
+        }
+
+        /**
+         * Sets the database factory. If not set, it defaults to
+         * {@link FrameworkSQLiteOpenHelperFactory}.
+         *
+         * @param factory The factory to use to access the database.
+         * @return this
+         */
+        public Builder<T> openHelperFactory(SupportSQLiteOpenHelper.Factory factory) {
+            mFactory = factory;
+            return this;
+        }
+
+        /**
+         * Version of the database, defaults to 1.
+         *
+         * @param version The database version to use
+         * @return this
+         */
+        public Builder<T> version(int version) {
+            mVersion = version;
+            return this;
+        }
+
+        /**
+         * Creates the databases and initializes it.
+         *
+         * @return A new database instance.
+         */
+        public T build() {
+            //noinspection ConstantConditions
+            if (mContext == null) {
+                throw new IllegalArgumentException("Cannot provide null context for the database.");
+            }
+            //noinspection ConstantConditions
+            if (mDatabaseClass == null) {
+                throw new IllegalArgumentException("Must provide an abstract class that"
+                        + " extends RoomDatabase");
+            }
+            if (mFactory == null) {
+                mFactory = new FrameworkSQLiteOpenHelperFactory();
+            }
+            DatabaseConfiguration configuration =
+                    new DatabaseConfiguration(mContext, mName, mVersion, mFactory);
+            T db = Room.getGeneratedImplementation(mDatabaseClass, DB_IMPL_SUFFIX);
+            db.init(configuration);
+            return db;
+        }
+    }
 }
diff --git a/room/runtime/src/test/java/com/android/support/room/BuilderTest.java b/room/runtime/src/test/java/com/android/support/room/BuilderTest.java
new file mode 100644
index 0000000..ef7fda0
--- /dev/null
+++ b/room/runtime/src/test/java/com/android/support/room/BuilderTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.support.room;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.mock;
+
+import android.content.Context;
+
+import com.android.support.db.SupportSQLiteOpenHelper;
+import com.android.support.db.framework.FrameworkSQLiteOpenHelperFactory;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class BuilderTest {
+    @Test(expected = IllegalArgumentException.class)
+    public void nullContext() {
+        //noinspection ConstantConditions
+        Room.databaseBuilder(null, RoomDatabase.class, "bla").build();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullContext2() {
+        //noinspection ConstantConditions
+        Room.inMemoryDatabaseBuilder(null, RoomDatabase.class).build();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullName() {
+        //noinspection ConstantConditions
+        Room.databaseBuilder(mock(Context.class), RoomDatabase.class, null).build();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void emptyName() {
+        Room.databaseBuilder(mock(Context.class), RoomDatabase.class, "  ").build();
+    }
+
+    @Test
+    public void createBasic() {
+        Context context = mock(Context.class);
+        TestDatabase db = Room.inMemoryDatabaseBuilder(context, TestDatabase.class).build();
+        assertThat(db, instanceOf(TestDatabase_Impl.class));
+        DatabaseConfiguration config = ((TestDatabase_Impl) db).mConfig;
+        assertThat(config, notNullValue());
+        assertThat(config.context, is(context));
+        assertThat(config.name, is(nullValue()));
+        assertThat(config.version, is(1));
+        assertThat(config.sqliteOpenHelperFactory,
+                instanceOf(FrameworkSQLiteOpenHelperFactory.class));
+    }
+
+    @Test
+    public void createWithFactoryAndVersion() {
+        Context context = mock(Context.class);
+        SupportSQLiteOpenHelper.Factory factory = mock(SupportSQLiteOpenHelper.Factory.class);
+
+        TestDatabase db = Room.inMemoryDatabaseBuilder(context, TestDatabase.class)
+                .version(41)
+                .openHelperFactory(factory)
+                .build();
+        assertThat(db, instanceOf(TestDatabase_Impl.class));
+        DatabaseConfiguration config = ((TestDatabase_Impl) db).mConfig;
+        assertThat(config, notNullValue());
+        assertThat(config.version, is(41));
+        assertThat(config.sqliteOpenHelperFactory, is(factory));
+    }
+
+    abstract static class TestDatabase extends RoomDatabase {}
+
+    static class TestDatabase_Impl extends TestDatabase {
+        DatabaseConfiguration mConfig;
+        @Override
+        public void init(DatabaseConfiguration configuration) {
+            super.init(configuration);
+            mConfig = configuration;
+        }
+
+        @Override
+        protected SupportSQLiteOpenHelper createOpenHelper(DatabaseConfiguration config) {
+            return null;
+        }
+    }
+}