diff --git a/build.gradle b/build.gradle
index b27411f..5a6b743 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,4 +1,4 @@
-allprojects {
+subprojects {
     apply plugin: 'idea'
 
     repositories {
@@ -12,6 +12,23 @@
     group = 'com.android.tools.build'
 }
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '1.3'
+// delay evaluation of this project before all subprojects have been evaluated.
+subprojects.each { subproject -> evaluationDependsOn(subproject.name) }
+
+def testTasks = subprojects.collect { it.tasks.withType(Test) }.flatten()
+
+task aggregateResults(type: Copy) {
+    from { testTasks*.testResultsDir }
+    into { file("build/results") }
 }
+aggregateResults.dependsOn testTasks
+
+task makeAggregateReport(dependsOn: aggregateResults) {
+    def report = new org.gradle.api.internal.tasks.testing.junit.report.DefaultTestReport(testReportDir: file("build/reports/tests"), testResultsDir: file("build/results"))
+    report.generateReport()
+}
+
+task check {
+    //nothing
+}
+check.dependsOn makeAggregateReport
diff --git a/builder/prebuilts/common.jar b/builder/prebuilts/common.jar
index 0398dbc..2bb2473 100644
--- a/builder/prebuilts/common.jar
+++ b/builder/prebuilts/common.jar
Binary files differ
diff --git a/builder/prebuilts/sdk_common.jar b/builder/prebuilts/sdk_common.jar
new file mode 100644
index 0000000..357543f
--- /dev/null
+++ b/builder/prebuilts/sdk_common.jar
Binary files differ
diff --git a/builder/src/main/java/com/android/builder/AndroidBuilder.java b/builder/src/main/java/com/android/builder/AndroidBuilder.java
index 55bacb8..b0ce8f3 100644
--- a/builder/src/main/java/com/android/builder/AndroidBuilder.java
+++ b/builder/src/main/java/com/android/builder/AndroidBuilder.java
@@ -35,9 +35,6 @@
 import com.android.builder.packaging.DuplicateFileException;
 import com.android.builder.packaging.PackagerException;
 import com.android.builder.packaging.SealedPackageException;
-import com.android.builder.resources.DuplicateResourceException;
-import com.android.builder.resources.ResourceMerger;
-import com.android.builder.resources.ResourceSet;
 import com.android.manifmerger.ManifestMerger;
 import com.android.manifmerger.MergerLog;
 import com.android.prefs.AndroidLocation.AndroidLocationException;
@@ -195,51 +192,6 @@
     }
 
     /**
-     * Merge resources together so that they can be fed to aapt.
-     *
-     * This also pre-processes the images (crunches the pngs and processes the 9 patch files)
-     * This is incremental.
-     *
-     * @param resOutputDir where the processed resources are stored.
-     * @param inputFolders the input resource folders
-     * @throws DuplicateResourceException
-     * @throws IOException
-     */
-    public void mergeResources(@NonNull String resOutputDir, @Nullable List<List<File>> inputFolders)
-            throws DuplicateResourceException, IOException {
-        checkState(mTarget != null, "Target not set.");
-        checkNotNull(resOutputDir, "resOutputDir cannot be null.");
-
-        if (inputFolders == null || inputFolders.isEmpty()) {
-            return;
-        }
-
-        ResourceMerger merger = new ResourceMerger();
-
-        boolean runMerger = false;
-
-        for (List<File> setFolders : inputFolders) {
-            // create a set and add all the folders from the list to it.
-            ResourceSet set = new ResourceSet();
-            for (File folder : setFolders) {
-                if (folder.isDirectory()) {
-                    set.addSource(folder);
-                }
-            }
-
-            if (!set.isEmpty()) {
-                merger.addResourceSet(set);
-                runMerger = true;
-            }
-        }
-
-        if (runMerger) {
-            ResourceSet mergedSet = merger.getMergedSet();
-            mergedSet.writeTo(new File(resOutputDir));
-        }
-    }
-
-    /**
      * Merges all the manifests into a single manifest
      *
      * @param mainManifest The main manifest of the application.
diff --git a/builder/src/main/java/com/android/builder/VariantConfiguration.java b/builder/src/main/java/com/android/builder/VariantConfiguration.java
index 0fbfbf9..f20c13c 100644
--- a/builder/src/main/java/com/android/builder/VariantConfiguration.java
+++ b/builder/src/main/java/com/android/builder/VariantConfiguration.java
@@ -19,12 +19,12 @@
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.annotations.VisibleForTesting;
+import com.android.builder.resources.ResourceSet;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 
 import java.io.File;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
@@ -151,7 +151,7 @@
      * @return the config object
      */
     public VariantConfiguration addProductFlavor(@NonNull ProductFlavor productFlavor,
-                                 @NonNull SourceProvider sourceProvider) {
+                                                 @NonNull SourceProvider sourceProvider) {
         mFlavorConfigs.add(productFlavor);
         mFlavorSourceProviders.add(sourceProvider);
         mMergedFlavor = productFlavor.mergeOver(mMergedFlavor);
@@ -506,53 +506,53 @@
     }
 
     /**
-     * Returns the dynamic list of resource sets based on the configuration, its dependencies,
+     * Returns the dynamic list of {@link ResourceSet} based on the configuration, its dependencies,
      * as well as tested config if applicable (test of a library).
      *
-     * The list is a list of folders. Each list of folder represents a
-     * {@link com.android.builder.resources.ResourceSet}.
-     *
      * The list is ordered in ascending order of importance, meaning the first set is meant to be
      * overridden by the 2nd one and so on. This is meant to facilitate usage of the list in a
      * {@link com.android.builder.resources.ResourceMerger}.
      *
-     * @return a list of list of resource folders.
+     * @return a list ResourceSet.
      */
-    @NonNull public List<List<File>> getResourceSets() {
-        List<List<File>> inputs = Lists.newArrayList();
+    @NonNull public List<ResourceSet> getResourceSets() {
+        List<ResourceSet> resourceSets = Lists.newArrayList();
 
         // the list of dependency must be reversed to use the right overlay order.
         for (int n = mFlatLibraries.size() - 1 ; n >= 0 ; n--) {
             AndroidDependency dependency = mFlatLibraries.get(n);
             File resFolder = dependency.getResFolder();
             if (resFolder != null) {
-                inputs.add(Collections.singletonList(resFolder));
+                ResourceSet resourceSet = new ResourceSet(dependency.getFolder().getName());
+                resourceSet.addSource(resFolder);
+                resourceSets.add(resourceSet);
             }
         }
 
         Set<File> mainResDirs = mDefaultSourceProvider.getResourcesDirectories();
-        List<File> mainSet = Lists.newArrayList();
-        mainSet.addAll(mainResDirs);
-        inputs.add(mainSet);
+
+        ResourceSet resourceSet = new ResourceSet("main");
+        resourceSet.addSources(mainResDirs);
+        resourceSets.add(resourceSet);
 
         // the list of flavor must be reversed to use the right overlay order.
         for (int n = mFlavorSourceProviders.size() - 1; n >= 0 ; n--) {
             SourceProvider sourceProvider = mFlavorSourceProviders.get(n);
 
             Set<File> flavorResDirs = sourceProvider.getResourcesDirectories();
-            List<File> flavorSet = Lists.newArrayList();
-            flavorSet.addAll(flavorResDirs);
-            inputs.add(flavorSet);
+            resourceSet = new ResourceSet(mFlavorConfigs.get(n).getName());
+            resourceSet.addSources(flavorResDirs);
+            resourceSets.add(resourceSet);
         }
 
         if (mBuildTypeSourceProvider != null) {
             Set<File> typeResDirs = mBuildTypeSourceProvider.getResourcesDirectories();
-            List<File> typeSet = Lists.newArrayList();
-            typeSet.addAll(typeResDirs);
-            inputs.add(typeSet);
+            resourceSet = new ResourceSet(mBuildType.getName());
+            resourceSet.addSources(typeResDirs);
+            resourceSets.add(resourceSet);
         }
 
-        return inputs;
+        return resourceSets;
     }
 
     public List<File> getAidlSourceList() {
diff --git a/builder/src/main/java/com/android/builder/internal/CommandLineRunner.java b/builder/src/main/java/com/android/builder/internal/CommandLineRunner.java
index e074267..81af9d9 100644
--- a/builder/src/main/java/com/android/builder/internal/CommandLineRunner.java
+++ b/builder/src/main/java/com/android/builder/internal/CommandLineRunner.java
@@ -44,7 +44,7 @@
 
         // get the output and return code from the process
         if (grabProcessOutput(process) != 0) {
-            throw new RuntimeException();
+            throw new RuntimeException(String.format("running %s failed. see output", command[0]));
         }
     }
 
diff --git a/builder/src/main/java/com/android/builder/internal/compiler/AidlProcessor.java b/builder/src/main/java/com/android/builder/internal/compiler/AidlProcessor.java
index 5d7de56..d7401de 100644
--- a/builder/src/main/java/com/android/builder/internal/compiler/AidlProcessor.java
+++ b/builder/src/main/java/com/android/builder/internal/compiler/AidlProcessor.java
@@ -63,14 +63,14 @@
         command.add("-p" + mFrameworkLocation);
         command.add("-o" + sourceOutputDir.getAbsolutePath());
         // add all the source folders as import in case an aidl file in a source folder
-        // imports a parcelable from another source folder.
+        // imports a parceleable from another source folder.
         for (File sourceFolder : sourceFolders) {
             if (sourceFolder.isDirectory()) {
                 command.add("-I" + sourceFolder.getAbsolutePath());
             }
         }
 
-        // add all the library aidl folders to access parcelables that are in libraries
+        // add all the library aidl folders to access parceleables that are in libraries
         for (File f : mImportFolders) {
             command.add("-I" + f.getAbsolutePath());
         }
diff --git a/builder/src/main/java/com/android/builder/internal/incremental/ChangeManager.java b/builder/src/main/java/com/android/builder/internal/incremental/ChangeManager.java
new file mode 100644
index 0000000..aca723e
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/internal/incremental/ChangeManager.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2012 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.builder.internal.incremental;
+
+import com.android.annotations.NonNull;
+import com.android.builder.resources.FileStatus;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * Class handling changes in input and output.
+ *
+ * The class stores the state of inputs/outputs after a task is run, and on subsequent runs can
+ * compare this to the current state of detect exact file changes in the inputs or outputs.
+ *
+ * Gradle already does this to figure out if a task needs to be run, but does not offer this
+ * information to the task.
+ * This should become available in the Gradle plugin in the future, but in the meantime this
+ * provides the same information, allowing us to build truly incremental tasks.
+ *
+ */
+public class ChangeManager {
+
+    private static final String FN_INPUTS_DATA = "inputs.data";
+    private static final String FN_OUTPUTS_DATA = "outputs.data";
+
+    private FileManager mInputs = new FileManager();
+    private FileManager mOutputs = new FileManager();
+
+    public ChangeManager() {
+    }
+
+    /**
+     * Loads the known state.
+     *
+     * @param incrementalFolder the folder in which to store the incremental data
+     * @return false if the loading failed.
+     */
+    public boolean load(File incrementalFolder) {
+        File inputs = new File(incrementalFolder, FN_INPUTS_DATA);
+        File outputs = new File(incrementalFolder, FN_OUTPUTS_DATA);
+        return inputs.exists() && outputs.exists() &&
+                mInputs.load(inputs) && mOutputs.load(outputs);
+    }
+
+    /**
+     * Writes the incremental data to a given folder.
+     * @param incrementalFolder the name of the folder to write to.
+     */
+    public void write(File incrementalFolder) {
+        incrementalFolder.mkdirs();
+
+        mInputs.write(new File(incrementalFolder, FN_INPUTS_DATA));
+        mOutputs.write(new File(incrementalFolder, FN_OUTPUTS_DATA));
+    }
+
+    /**
+     * Delete the incremental data from the given folder.
+     * @param incrementalFolder the folder to delete the incremental data from.
+     */
+    public static void delete(File incrementalFolder) {
+        File file = new File(incrementalFolder, FN_INPUTS_DATA);
+        file.delete();
+        file = new File(incrementalFolder, FN_OUTPUTS_DATA);
+        file.delete();
+    }
+
+    /**
+     * Add an input file or folder.
+     * @param file the file.
+     */
+    public void addInput(File file) {
+        mInputs.addFile(file);
+    }
+
+    /**
+     * Adds a new output file or folder
+     * @param file the file.
+     */
+    public void addOutput(File file) {
+        mOutputs.addFile(file);
+    }
+
+    /**
+     * Get the list of changed inputs. Empty list means no input changes.
+     *
+     * @return a map of (File, FileStatus) for all changed input.
+     */
+    @NonNull
+    public Map<File, FileStatus> getChangedInputs() {
+        return mInputs.getChangedFiles();
+    }
+
+    /**
+     * Returns a list of changed output. Empty list means no output changes.
+     *
+     * @return a map of (file, status) for all changed output files.
+     */
+    @NonNull
+    public Map<File, FileStatus> getChangedOutputs() {
+        return mOutputs.getChangedFiles();
+    }
+
+    /**
+     * Update the outputs before writing the file states
+     */
+    public void updateOutputs(Collection<File> outputs) {
+        mOutputs.update(outputs);
+    }
+}
diff --git a/builder/src/main/java/com/android/builder/internal/incremental/FileEntity.java b/builder/src/main/java/com/android/builder/internal/incremental/FileEntity.java
new file mode 100644
index 0000000..17eae4c
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/internal/incremental/FileEntity.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (C) 2012 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.builder.internal.incremental;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.util.Formatter;
+
+/**
+ * A {@link File} and its associated data needed to figure out if a file changed or not.
+ */
+class FileEntity {
+
+    private static final byte[] sBuffer = new byte[4096];
+
+    private final File file;
+    private final long lastModified;
+    private long length;
+    private String sha1;
+
+    /**
+     * Exception to indicate a failure to check a jar file's content.
+     */
+    private static final class Sha1Exception extends Exception {
+        private static final long serialVersionUID = 1L;
+        private final File file;
+
+        public Sha1Exception(File jarFile, Throwable cause) {
+            super(cause);
+            file = jarFile;
+        }
+
+        public File getJarFile() {
+            return file;
+        }
+    }
+
+    /**
+     * Creates an entity from cached data.
+     *
+     * @param file the file
+     * @param lastModified when it was last modified
+     * @param length its length
+     * @param sha1 its sha1
+     */
+    FileEntity(File file, long lastModified, long length, String sha1) {
+        this.file = file;
+        this.lastModified = lastModified;
+        this.length = length;
+        this.sha1 = sha1;
+    }
+
+    /**
+     * Creates an entity from a {@link File}.
+     *
+     * The sha1 is not computed yet, it'll be done on demand when {@link #getSha1()} is called.
+     *
+     * @param file the file.
+     */
+    FileEntity(File file) {
+        this.file = file;
+        lastModified = file.lastModified();
+        length = file.length();
+    }
+
+    /**
+     * Returns the file's last modified info.
+     * @return the file's last modified info.
+     */
+    long getLastModified() {
+        return lastModified;
+    }
+
+    /**
+     * Return the file length.
+     * @return the file length.
+     */
+    long getLength() {
+        return length;
+    }
+
+    /**
+     * Returns the file this entity represents.
+     * @return the file.
+     */
+    File getFile() {
+        return file;
+    }
+
+    /**
+     * Returns the file's sha1, computing it if necessary.
+     *
+     * @return the sha1 or null if it couldn't be computed.
+     */
+    String getSha1() {
+        try {
+            return computeAndReturnSha1();
+        } catch (Sha1Exception e) {
+            return null;
+        }
+    }
+
+    /**
+     * Checks whether the {@link File#lastModified()} matches the cached value. If not, length
+     * is updated and the sha1 is reset (but not recomputed, this is done on demand).
+     *
+     * @return return whether the file was changed.
+     */
+    private boolean checkValidity() {
+        if (lastModified != file.lastModified()) {
+            length = file.length();
+            sha1 = null;
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns whether the two entity are different files.
+     *
+     * This will compute the files' sha1 if they are not yet computed.
+     *
+     * @param fileEntity the file to compare to.
+     * @return true if the files are the same, false otherwise.
+     */
+    public boolean isDifferentThan(FileEntity fileEntity) {
+        assert fileEntity.file.equals(file);
+
+        // same date, same files.
+        if (lastModified == fileEntity.lastModified) {
+            return false;
+        }
+
+        try {
+            // different date doesn't necessarily mean different file.
+            // start with size, less computing intensive than sha1.
+            return length != fileEntity.length ||
+                    !computeAndReturnSha1().equals(fileEntity.computeAndReturnSha1());
+        } catch (Sha1Exception e) {
+            // if we can't compute the sha1, we consider the files different.
+            return true;
+        }
+    }
+
+    /**
+     * Returns the file's sha1, computing it if necessary.
+     *
+     * @return the sha1
+     * @throws Sha1Exception
+     */
+    private String computeAndReturnSha1() throws Sha1Exception {
+        if (sha1 == null) {
+            sha1 = getSha1(file);
+        }
+        return sha1;
+    }
+
+    /**
+     * Computes the sha1 of a file and returns it.
+     *
+     * @param f the file to compute the sha1 for.
+     * @return the sha1 value
+     * @throws Sha1Exception if the sha1 value cannot be computed.
+     */
+    static String getSha1(File f) throws Sha1Exception {
+        synchronized (sBuffer) {
+            FileInputStream fis = null;
+            try {
+                MessageDigest md = MessageDigest.getInstance("SHA-1");
+
+                fis = new FileInputStream(f);
+                while (true) {
+                    int length = fis.read(sBuffer);
+                    if (length > 0) {
+                        md.update(sBuffer, 0, length);
+                    } else {
+                        break;
+                    }
+                }
+
+                return byteArray2Hex(md.digest());
+
+            } catch (Exception e) {
+                throw new Sha1Exception(f, e);
+            } finally {
+                if (fis != null) {
+                    try {
+                        fis.close();
+                    } catch (IOException e) {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Converts a byte array to an Hex string.
+     * @param hash the byte array to convert,
+     * @return the converted string.
+     */
+    private static String byteArray2Hex(final byte[] hash) {
+        Formatter formatter = new Formatter();
+        try {
+            for (byte b : hash) {
+                formatter.format("%02x", b);
+            }
+            return formatter.toString();
+        } finally {
+            formatter.close();
+        }
+    }
+}
diff --git a/builder/src/main/java/com/android/builder/internal/incremental/FileManager.java b/builder/src/main/java/com/android/builder/internal/incremental/FileManager.java
new file mode 100644
index 0000000..ff47c6a
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/internal/incremental/FileManager.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2012 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.builder.internal.incremental;
+
+import com.android.annotations.NonNull;
+import com.android.builder.resources.FileStatus;
+import com.google.common.collect.Maps;
+
+import java.io.*;
+import java.util.Collection;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Class handling changes in a set of files.
+ *
+ * The class can store the state of the files, and later reload it and compare it to the
+ * previous known state.
+ *
+ */
+class FileManager {
+
+    private static final Pattern READ_PATTERN = Pattern.compile("^(\\d+) (\\d+) ([0-9a-f]+) (.+)$");
+
+    private Map<File, FileEntity> mLoadedFiles = Maps.newHashMap();
+    private Map<File, FileEntity> mProcessedFiles = Maps.newHashMap();
+    private Map<File, FileStatus> mResults = Maps.newHashMap();
+
+    public FileManager() {
+    }
+
+    /**
+     * Loads the known state.
+     *
+     * @param stateFile the file to load the state from.
+     * @return false if the loading failed.
+     *
+     * @see #write(java.io.File)
+     */
+    public boolean load(File stateFile) {
+        if (!stateFile.exists()) {
+            return false;
+        }
+
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new InputStreamReader(
+                    new FileInputStream(stateFile), "UTF-8"));
+
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                // skip comments
+                if (line.charAt(0) == '#') {
+                    continue;
+                }
+
+                // get the data with a regexp
+                Matcher m = READ_PATTERN.matcher(line);
+                if (m.matches()) {
+                    String path = m.group(4);
+                    File f = new File(path);
+
+                    FileEntity entity = new FileEntity(
+                            f,
+                            Long.parseLong(m.group(1)),
+                            Long.parseLong(m.group(2)),
+                            m.group(3));
+
+                    mLoadedFiles.put(f, entity);
+                }
+            }
+
+            return true;
+        } catch (FileNotFoundException ignored) {
+            // won't happen, we check up front.
+        } catch (UnsupportedEncodingException ignored) {
+            // shouldn't happen, but if it does, we just won't have a cache.
+        } catch (IOException ignored) {
+            // shouldn't happen, but if it does, we just won't have a cache.
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException ignored) {
+                    // ignore
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Writes the state to a file
+     * @param stateFile the file to write the state to.
+     *
+     * @see #load(java.io.File)
+     */
+    public void write(File stateFile) {
+        OutputStreamWriter writer = null;
+        try {
+            // first make sure the folders exist!
+            File parentFolder = stateFile.getParentFile();
+            parentFolder.mkdirs();
+
+            // then write the file.
+            writer = new OutputStreamWriter(new FileOutputStream(stateFile), "UTF-8");
+
+            writer.write("# incremental data. DO NOT EDIT.\n");
+            writer.write("# format is <lastModified> <length> <SHA-1> <path>\n");
+            writer.write("# Encoding is UTF-8\n");
+
+            for (FileEntity entity : mProcessedFiles.values()) {
+                String sha1 = entity.getSha1();
+                if (sha1 == null) {
+                    sha1 = "0123456789012345678901234567890123456789"; // TODO: find a better way to detect missing sha1
+                }
+
+                writer.write(String.format("%d %d %s %s\n",
+                        entity.getLastModified(),
+                        entity.getLength(),
+                        sha1,
+                        entity.getFile().getAbsolutePath()));
+            }
+        } catch (IOException ignored) {
+        } finally {
+            if (writer != null) {
+                try {
+                    writer.close();
+                } catch (IOException ignored) {
+                }
+            }
+        }
+    }
+
+   /**
+     * Add an input file or folder.
+     * @param file the file.
+     */
+    public void addFile(File file) {
+        processFile(file);
+    }
+
+    /**
+     * Get the list of changed inputs. Empty list means no input changes.
+     *
+     * @return a map of (File, FileStatus) for all changed input.
+     */
+    @NonNull
+    public Map<File, FileStatus> getChangedFiles() {
+        // at this point, all the files that needed processing have been processed,
+        // but there may be removed files remaining in the loaded file map.
+        for (File f : mLoadedFiles.keySet()) {
+            mResults.put(f, FileStatus.REMOVED);
+        }
+
+        return mResults;
+    }
+
+    private void processFile(File file) {
+        if (file.isFile()) {
+            if (file.getName().startsWith(".")) {
+                return;
+            }
+
+            // get the FileEntity for the new(?) version.
+            FileEntity newFileEntity = new FileEntity(file);
+
+            // see if it existed before.
+            FileEntity fileEntity = mLoadedFiles.get(file);
+
+            if (fileEntity == null) {
+                // new file!
+                mResults.put(file, FileStatus.NEW);
+
+                // add it to the list of processed files
+                mProcessedFiles.put(file, newFileEntity);
+            } else {
+                // remove it from the loaded files.
+                mLoadedFiles.remove(file);
+
+                if (newFileEntity.isDifferentThan(fileEntity)) {
+                    mResults.put(file, FileStatus.CHANGED);
+
+                    // put the newFileEntity in the processed files.
+                    mProcessedFiles.put(file, newFileEntity);
+                } else {
+                    // just move the original entity so avoid recomputing the sha1.
+                    // FileEntity.isDifferentThan doesn't necessarily compute it.
+                   mProcessedFiles.put(file, fileEntity);
+                }
+            }
+        } else if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            if (files != null && files.length > 0) {
+                for (File f : files) {
+                    processFile(f);
+                }
+            }
+         }
+    }
+
+    /**
+     * Updates the existing files with the given files/folders.
+     * @param files the new folders/files to process.
+     */
+    void update(Collection<File> files) {
+        mLoadedFiles.clear();
+        mLoadedFiles.putAll(mProcessedFiles);
+        mResults.clear();
+        mProcessedFiles.clear();
+        for (File f : files) {
+            processFile(f);
+        }
+    }
+}
diff --git a/builder/src/main/java/com/android/builder/resources/FileStatus.java b/builder/src/main/java/com/android/builder/resources/FileStatus.java
new file mode 100644
index 0000000..45c3d72
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/resources/FileStatus.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2012 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.builder.resources;
+
+/**
+ * File change state.
+ */
+public enum FileStatus {
+    NEW, REMOVED, CHANGED
+}
diff --git a/builder/src/main/java/com/android/builder/resources/NodeUtils.java b/builder/src/main/java/com/android/builder/resources/NodeUtils.java
new file mode 100644
index 0000000..dcdfa2a
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/resources/NodeUtils.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2012 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.builder.resources;
+
+import com.android.SdkConstants;
+import com.android.annotations.VisibleForTesting;
+import org.w3c.dom.*;
+
+/**
+ * Utility class to handle Nodes.
+ *
+ * - convert Node from one XML {@link Document} to be used by another Document
+ * - compare Nodes and attributes.
+ */
+class NodeUtils {
+
+    /**
+     * Makes a new document adopt a node from a different document, and correctly reassign namespace
+     * and prefix
+     * @param document the new document
+     * @param node the node to adopt.
+     * @return the adopted node.
+     */
+    static Node adoptNode(Document document, Node node) {
+        Node newNode = document.adoptNode(node);
+
+        updateNamespace(newNode, document);
+
+        return newNode;
+    }
+
+    static void addAttribute(Document document, Node node,
+                             String NamespaceUri, String attrName, String attrValue) {
+        Attr attr;
+        if (NamespaceUri != null) {
+            attr = document.createAttributeNS(NamespaceUri, attrName);
+        } else {
+            attr = document.createAttribute(attrName);
+        }
+
+        attr.setValue(attrValue);
+
+        if (NamespaceUri != null) {
+            node.getAttributes().setNamedItemNS(attr);
+        } else {
+            node.getAttributes().setNamedItem(attr);
+        }
+    }
+
+    /**
+     * Updates the namespace of a given node (and its children) to work in a given document
+     * @param node the node to update
+     * @param document the new document
+     */
+    private static void updateNamespace(Node node, Document document) {
+
+        // first process this node
+        processSingleNodeNamespace(node, document);
+
+        // then its attributes
+        NamedNodeMap attributes = node.getAttributes();
+        if (attributes != null) {
+            for (int i = 0, n = attributes.getLength(); i < n; i++) {
+                processSingleNodeNamespace(attributes.item(i), document);
+            }
+        }
+
+        // then do it for the children nodes.
+        NodeList children = node.getChildNodes();
+        if (children != null) {
+            for (int i = 0, n = children.getLength(); i < n; i++) {
+                Node child = children.item(i);
+                if (child != null) {
+                    updateNamespace(child, document);
+                }
+            }
+        }
+    }
+
+    /**
+     * Update the namespace of a given node to work with a given document.
+     * @param node the node to update
+     * @param document the new document
+     */
+    private static void processSingleNodeNamespace(Node node, Document document) {
+        String ns = node.getNamespaceURI();
+        if (ns != null) {
+            NamedNodeMap docAttributes = document.getAttributes();
+
+            String prefix = getPrefixForNs(docAttributes, ns);
+            if (prefix == null) {
+                prefix = getUniqueNsAttribute(docAttributes);
+                Attr nsAttr = document.createAttribute(prefix);
+                nsAttr.setValue(ns);
+                document.getChildNodes().item(0).getAttributes().setNamedItem(nsAttr);
+            }
+
+            // set the prefix on the node, by removing the xmlns: start
+            prefix = prefix.substring(6);
+            node.setPrefix(prefix);
+        }
+    }
+
+    /**
+     * Looks for an existing prefix for a a given namespace.
+     * The prefix must start with "xmlns:". The whole prefix is returned.
+     * @param attributes the list of attributes to look through
+     * @param ns the namespace to find.
+     * @return the found prefix or null if none is found.
+     */
+    private static String getPrefixForNs(NamedNodeMap attributes, String ns) {
+        if (attributes != null) {
+            for (int i = 0, n = attributes.getLength(); i < n; i++) {
+                Attr attribute = (Attr) attributes.item(i);
+                if (ns.equals(attribute.getValue()) && ns.startsWith(SdkConstants.XMLNS_PREFIX)) {
+                    return attribute.getName();
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static String getUniqueNsAttribute(NamedNodeMap attributes) {
+        if (attributes == null) {
+            return "xmlns:ns1";
+        }
+
+        int i = 2;
+        while (true) {
+            String name = String.format("xmlns:ns%d", i++);
+            if (attributes.getNamedItem(name) == null) {
+                return name;
+            }
+        }
+    }
+
+    static boolean compareElementNode(Node node1, Node node2) {
+        if (!node1.getNodeName().equals(node2.getNodeName())) {
+            return false;
+        }
+
+        NamedNodeMap attr1 = node1.getAttributes();
+        NamedNodeMap attr2 = node2.getAttributes();
+
+        return compareAttributes(attr1, attr2) &&
+                compareChildren(node1.getChildNodes(), node2.getChildNodes());
+
+    }
+
+    private static boolean compareChildren(NodeList children1, NodeList children2) {
+        // because this represents a resource values, we're going to be very strict about this
+        // comparison.
+        if (children1.getLength() != children2.getLength()) {
+            return false;
+        }
+
+        for (int i = 0, n = children1.getLength(); i < n; i++) {
+            Node child1 = children1.item(i);
+            Node child2 = children2.item(i);
+
+            short nodeType = child1.getNodeType();
+            if (nodeType != child2.getNodeType()) {
+                return false;
+            }
+
+            switch (nodeType) {
+                case Node.ELEMENT_NODE:
+                    if (!compareElementNode(child1, child2)) {
+                        return false;
+                    }
+                    break;
+                case Node.TEXT_NODE:
+                case Node.COMMENT_NODE:
+                    if (!child1.getNodeValue().trim().equals(child2.getNodeValue().trim())) {
+                        return false;
+                    }
+                    break;
+            }
+        }
+
+        return true;
+    }
+
+    @VisibleForTesting
+    static boolean compareAttributes(NamedNodeMap attrMap1, NamedNodeMap attrMap2) {
+        if (attrMap1.getLength() != attrMap2.getLength()) {
+            return false;
+        }
+
+        for (int i = 0, n = attrMap1.getLength(); i < n; i++) {
+            Attr attr1 = (Attr) attrMap1.item(i);
+
+            String ns1 = attr1.getNamespaceURI();
+
+            Attr attr2;
+            if (ns1 != null) {
+                attr2 = (Attr) attrMap2.getNamedItemNS(ns1, attr1.getLocalName());
+            }  else {
+                attr2 = (Attr) attrMap2.getNamedItem(attr1.getName());
+            }
+
+            if (attr2 == null || !attr2.getValue().equals(attr1.getValue())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/builder/src/main/java/com/android/builder/resources/Resource.java b/builder/src/main/java/com/android/builder/resources/Resource.java
index b5dd69c..65f476c 100644
--- a/builder/src/main/java/com/android/builder/resources/Resource.java
+++ b/builder/src/main/java/com/android/builder/resources/Resource.java
@@ -16,6 +16,7 @@
 
 package com.android.builder.resources;
 
+import com.android.annotations.NonNull;
 import com.android.resources.ResourceType;
 import org.w3c.dom.Node;
 
@@ -26,59 +27,219 @@
  * in case of a resource coming from a value file.
  *
  */
-public class Resource {
+class Resource {
+
+    private static final int MASK_TOUCHED = 0x01;
+    private static final int MASK_REMOVED = 0x02;
+    private static final int MASK_WRITTEN = 0x10;
 
     private final String mName;
     private final ResourceType mType;
 
-    private final Node mValue;
+    private Node mValue;
     private ResourceFile mSource;
 
-    Resource(String name, ResourceType type, Node value) {
+    /**
+     * The status of the Resource. It's a bit mask as opposed to an enum
+     * to differentiate removed and removed+written
+     */
+    private int mStatus = 0;
+
+    /**
+     * Constructs the object with a name, type and optional value.
+     *
+     * Note that the object is not fully usable as-is. It must be added to a ResourceFile first.
+     *
+     * @param name the name of the resource
+     * @param type the type of the resource
+     * @param value an optional Node that represents the resource value.
+     */
+    Resource(@NonNull String name, @NonNull ResourceType type, Node value) {
         mName = name;
         mType = type;
         mValue = value;
     }
 
+    /**
+     * Returns the name of the resource.
+     * @return the name.
+     */
+    @NonNull
     public String getName() {
         return mName;
     }
 
+    /**
+     * Returns the type of the resource.
+     * @return the type.
+     */
+    @NonNull
     public ResourceType getType() {
         return mType;
     }
 
+    /**
+     * Returns the ResourceFile the resource is coming from. Can be null.
+     * @return the resource file.
+     */
     public ResourceFile getSource() {
         return mSource;
     }
 
+    /**
+     * Returns the optional value of the resource. Can be null
+     * @return the value or null.
+     */
     public Node getValue() {
         return mValue;
     }
 
+    /**
+     * Sets the value of the resource and set its state to TOUCHED.
+     * @param from the resource to copy the value from.
+     */
+    void setValue(Resource from) {
+        mValue = from.mValue;
+        setTouched();
+    }
+
+
+    /**
+     * Sets the ResourceFile
+     * @param sourceFile the ResourceFile
+     */
     void setSource(ResourceFile sourceFile) {
         mSource = sourceFile;
     }
 
     /**
+     * Resets the state of the resource be WRITTEN. All other states are removed.
+     * @return this
+     *
+     * @see #isWritten()
+     */
+    Resource resetStatusToWritten() {
+        mStatus = MASK_WRITTEN;
+        return this;
+    }
+
+    /**
+     * Sets the resource be WRITTEN. Other states are kept.
+     * @return this
+     *
+     * @see #isWritten()
+     */
+    Resource setWritten() {
+        mStatus |= MASK_WRITTEN;
+        return this;
+    }
+
+    /**
+     * Sets the resource be REMOVED. Other states are kept.
+     * @return this
+     *
+     * @see #isRemoved()
+     */
+    Resource setRemoved() {
+        mStatus |= MASK_REMOVED;
+        return this;
+    }
+
+    /**
+     * Sets the resource be TOUCHED. Other states are kept.
+     * @return this
+     *
+     * @see #isTouched()
+     */
+    Resource setTouched() {
+        mStatus |= MASK_TOUCHED;
+        return this;
+    }
+
+    /**
+     * Returns whether the resource is REMOVED
+     * @return true if removed
+     */
+    boolean isRemoved() {
+        return (mStatus & MASK_REMOVED) != 0;
+    }
+
+    /**
+     * Returns whether the resource is TOUCHED
+     * @return true if touched
+     */
+    boolean isTouched() {
+        return (mStatus & MASK_TOUCHED) != 0;
+    }
+
+    /**
+     * Returns whether the resource is WRITTEN
+     * @return true if written
+     */
+    boolean isWritten() {
+        return (mStatus & MASK_WRITTEN) != 0;
+    }
+
+    /**
      * Returns a key for this resource. They key uniquely identifies this resource by combining
      * resource type, qualifiers, and name.
+     *
+     * If the resource has not been added to a {@link ResourceFile}, this will throw an
+     * {@link IllegalStateException}.
+     *
      * @return the key for this resource.
+     *
+     * @throws IllegalStateException if the resource is not added to a ResourceFile
      */
     String getKey() {
-        String qualifiers = mSource != null ? mSource.getQualifiers() : null;
-        if (qualifiers != null) {
+        if (mSource == null) {
+            throw new IllegalStateException(
+                    "Resource.getKey called on object with no ResourceFile: " + this);
+        }
+        String qualifiers = mSource.getQualifiers();
+        if (qualifiers != null && qualifiers.length() > 0) {
             return mType.getName() + "-" + qualifiers + "/" + mName;
         }
 
         return mType.getName() + "/" + mName;
     }
 
+    /**
+     * Compares the Resource {@link #getValue()} together and returns true if they are the same.
+     * @param resource The Resource object to compare to.
+     * @return true if equal
+     */
+    public boolean compareValueWith(Resource resource) {
+        if (mValue != null && resource.mValue != null) {
+            return NodeUtils.compareElementNode(mValue, resource.mValue);
+        }
+
+        return mValue == resource.mValue;
+    }
+
     @Override
     public String toString() {
         return "Resource{" +
                 "mName='" + mName + '\'' +
                 ", mType=" + mType +
+                ", mStatus=" + mStatus +
                 '}';
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Resource resource = (Resource) o;
+
+        return mName.equals(resource.mName) && mType == resource.mType;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = mName.hashCode();
+        result = 31 * result + mType.hashCode();
+        return result;
+    }
 }
diff --git a/builder/src/main/java/com/android/builder/resources/ResourceFile.java b/builder/src/main/java/com/android/builder/resources/ResourceFile.java
index 7c335ee..42ba9bc 100644
--- a/builder/src/main/java/com/android/builder/resources/ResourceFile.java
+++ b/builder/src/main/java/com/android/builder/resources/ResourceFile.java
@@ -18,43 +18,111 @@
 
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
-import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 
 import java.io.File;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 /**
+ * Represents a file in a resource folders.
+ *
+ * It contains a link to the {@link File}, the qualifier string (which is the name of the folder
+ * after the first '-' character), a list of {@link Resource} and a type.
+ *
+ * The type of the file is based on whether the file is located in a values folder (FileType.MULTI)
+ * or in another folder (FileType.SINGLE).
  */
 class ResourceFile {
 
+    static enum FileType {
+        SINGLE, MULTI
+    }
+
+    private final FileType mType;
     private final File mFile;
-    private final List<Resource> mItems;
+    private final Map<String, Resource> mItems;
     private final String mQualifiers;
 
-    ResourceFile(File file, Resource item, String qualifiers) {
+    /**
+     * Creates a resource file with a single resource item.
+     *
+     * The source file is set on the item with {@link Resource#setSource(ResourceFile)}
+     *
+     * The type of the ResourceFile will by {@link FileType#SINGLE}.
+     *
+     * @param file the File
+     * @param item the resource item
+     * @param qualifiers the qualifiers.
+     */
+    ResourceFile(@NonNull File file, @NonNull Resource item, @Nullable String qualifiers) {
+        mType = FileType.SINGLE;
         mFile = file;
-        mItems = Collections.singletonList(item);
         mQualifiers = qualifiers;
 
         item.setSource(this);
+        mItems = Collections.singletonMap(item.getKey(), item);
     }
 
+    /**
+     * Creates a resource file with a list of resource items.
+     *
+     * The source file is set on the items with {@link Resource#setSource(ResourceFile)}
+     *
+     * The type of the ResourceFile will by {@link FileType#MULTI}.
+     *
+     * @param file the File
+     * @param items the resource items
+     * @param qualifiers the qualifiers.
+     */
     ResourceFile(@NonNull File file, @NonNull List<Resource> items, @Nullable String qualifiers) {
+        mType = FileType.MULTI;
         mFile = file;
-        mItems = Lists.newArrayList(items);
         mQualifiers = qualifiers;
 
+        mItems = Maps.newHashMapWithExpectedSize(items.size());
         for (Resource item : items) {
             item.setSource(this);
+            mItems.put(item.getKey(), item);
         }
     }
 
-    @NonNull File getFile() {
+    @NonNull
+    FileType getType() {
+        return mType;
+    }
+
+    @NonNull
+    File getFile() {
         return mFile;
     }
 
-    @Nullable String getQualifiers() {
+    @Nullable
+    String getQualifiers() {
         return mQualifiers;
     }
+
+    Resource getItem() {
+        assert mItems.size() == 1;
+        return mItems.values().iterator().next();
+    }
+
+    @NonNull
+    Collection<Resource> getItems() {
+        return mItems.values();
+    }
+
+    @NonNull
+    Map<String, Resource> getItemMap() {
+        return mItems;
+    }
+
+    void addItems(Collection<Resource> items) {
+        for (Resource item : items) {
+            mItems.put(item.getKey(), item);
+            item.setSource(this);
+        }
+    }
 }
diff --git a/builder/src/main/java/com/android/builder/resources/ResourceMap.java b/builder/src/main/java/com/android/builder/resources/ResourceMap.java
new file mode 100644
index 0000000..cd1f5d9
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/resources/ResourceMap.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2012 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.builder.resources;
+
+import com.android.annotations.NonNull;
+import com.google.common.collect.ListMultimap;
+
+/**
+ * A Resource Map able to provide a {@link ListMultimap} of Resources where the keys are
+ * the value returned by {@link Resource#getKey()}
+ */
+interface ResourceMap {
+
+    /**
+     * Returns the number of resources.
+     * @return the number of resources.
+     */
+    int size();
+
+    /**
+     * a Multi map of (key, resource) where key is the result of
+     * {@link com.android.builder.resources.Resource#getKey()}
+     * @return a non null map
+     */
+    @NonNull
+    ListMultimap<String, Resource> getResourceMap();
+}
diff --git a/builder/src/main/java/com/android/builder/resources/ResourceMerger.java b/builder/src/main/java/com/android/builder/resources/ResourceMerger.java
index a059ec2..88dab2f 100644
--- a/builder/src/main/java/com/android/builder/resources/ResourceMerger.java
+++ b/builder/src/main/java/com/android/builder/resources/ResourceMerger.java
@@ -16,33 +16,584 @@
 
 package com.android.builder.resources;
 
-import com.google.common.collect.Maps;
+import com.android.SdkConstants;
+import com.android.annotations.NonNull;
+import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlPrettyPrinter;
+import com.android.resources.ResourceFolderType;
+import com.android.utils.Pair;
+import com.google.common.base.Charsets;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.io.Files;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
 
-import java.util.Map;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.*;
 
 /**
+ * Merges {@link ResourceSet}s and writes a resource folder that can be fed to aapt.
+ *
+ * This is able to save its post work state and reload this for incremental update.
  */
-public class ResourceMerger {
+public class ResourceMerger implements ResourceMap {
+
+    static final String FN_MERGER_XML = "merger.xml";
+    private static final String FN_VALUES_XML = "values.xml";
+    private static final String NODE_MERGER = "merger";
+    private static final String NODE_RESOURCE_SET = "resourceSet";
 
     /**
-     * The merged resources
+     * All the resources. The merged version will be the last item in the list.
      */
-    private final Map<String, Resource> mItems = Maps.newHashMap();
+    private final List<ResourceSet> mResourceSets = Lists.newArrayList();
 
-    public ResourceMerger() {
-
-    }
+    public ResourceMerger() { }
 
     /**
-     * adds a new sourceset and overlays it on top of the existing resource items
+     * adds a new {@link ResourceSet} and overlays it on top of the existing ResourceSets.
+     *
      * @param resourceSet the ResourceSet to add.
      */
     public void addResourceSet(ResourceSet resourceSet) {
         // TODO figure out if we allow partial overlay through a per-resource flag.
-        mItems.putAll(resourceSet.getResourceMap());
+        mResourceSets.add(resourceSet);
     }
 
-    public ResourceSet getMergedSet() {
-        return new ResourceSet(mItems);
+    /**
+     * Returns the list of ResourceSet objects.
+     * @return the resource sets.
+     */
+    @VisibleForTesting
+    List<ResourceSet> getResourceSets() {
+        return mResourceSets;
+    }
+
+    @VisibleForTesting
+    void validateResourceSets() throws DuplicateResourceException {
+        for (ResourceSet resourceSet : mResourceSets) {
+            resourceSet.checkItems();
+        }
+    }
+
+    /**
+     * Returns the number of resources.
+     * @return the number of resources.
+     *
+     * @see ResourceMap
+     */
+    @Override
+    public int size() {
+        // put all the resource keys in a set.
+        Set<String> keys = Sets.newHashSet();
+
+        for (ResourceSet resourceSet : mResourceSets) {
+            ListMultimap<String, Resource> map = resourceSet.getResourceMap();
+            keys.addAll(map.keySet());
+        }
+
+        return keys.size();
+    }
+
+    /**
+     * Returns a map of the resources.
+     * @return a map of items.
+     *
+     * @see ResourceMap
+     */
+    @NonNull
+    @Override
+    public ListMultimap<String, Resource> getResourceMap() {
+        // put all the sets in a multimap. The result is that for each key,
+        // there is a sorted list of items from all the layers, including removed ones.
+        ListMultimap<String, Resource> fullItemMultimap = ArrayListMultimap.create();
+
+        for (ResourceSet resourceSet : mResourceSets) {
+            ListMultimap<String, Resource> map = resourceSet.getResourceMap();
+            for (Map.Entry<String, Collection<Resource>> entry : map.asMap().entrySet()) {
+                fullItemMultimap.putAll(entry.getKey(), entry.getValue());
+            }
+        }
+
+        return fullItemMultimap;
+    }
+
+    /**
+     * Writes the result of the merge to a destination resource folder.
+     *
+     * The output is an Android style resource folder than can be fed to aapt.
+     *
+     * @param rootFolder the folder to write the resources in.
+     * @throws IOException
+     * @throws DuplicateResourceException
+     */
+    public void writeResourceFolder(File rootFolder)
+            throws IOException, DuplicateResourceException {
+        // get all the resource keys.
+        Set<String> resourceKeys = Sets.newHashSet();
+
+        for (ResourceSet resourceSet : mResourceSets) {
+            // quick check on duplicates in the resource set.
+            resourceSet.checkItems();
+            ListMultimap<String, Resource> map = resourceSet.getResourceMap();
+            resourceKeys.addAll(map.keySet());
+        }
+
+        // map of XML values files to write after parsing all the files.
+        // the key is the qualifier.
+        ListMultimap<String, Resource> valuesResMap = ArrayListMultimap.create();
+        // set of qualifier that was a previously written resource disappear. This is to keep track
+        // of which file to write if no other resources are touched.
+        Set<String> qualifierWithDeletedValues = Sets.newHashSet();
+
+        // loop on all the resources.
+        for (String resourceKey : resourceKeys) {
+            // for each resource, look in the resource sets, starting from the end of the list.
+
+            Resource previouslyWritten = null;
+            Resource toWrite = null;
+
+            /*
+             * We are looking for what to write/delete: the last non deleted item, and the
+             * previously written one.
+             */
+
+            setLoop: for (int i = mResourceSets.size() - 1 ; i >= 0 ; i--) {
+                ResourceSet resourceSet = mResourceSets.get(i);
+
+                // look for the resource key in the set
+                ListMultimap<String, Resource> resourceMap = resourceSet.getResourceMap();
+
+                List<Resource> resources = resourceMap.get(resourceKey);
+                if (resources.isEmpty()) {
+                    continue;
+                }
+
+                // The list can contain at max 2 items. One touched and one deleted.
+                // More than one deleted means there was more than one which isn't possible
+                // More than one touched means there is more than one and this isn't possible.
+                for (int ii = resources.size() - 1 ; ii >= 0 ; ii--) {
+                    Resource resource = resources.get(ii);
+
+                    if (resource.isWritten()) {
+                        assert previouslyWritten == null;
+                        previouslyWritten = resource;
+                    }
+
+                    if (toWrite == null && !resource.isRemoved()) {
+                        toWrite = resource;
+                    }
+
+                    if (toWrite != null && previouslyWritten != null) {
+                        break setLoop;
+                    }
+                }
+            }
+
+            // done searching, we should at least have something.
+            assert previouslyWritten != null || toWrite != null;
+
+            // now need to handle, the type of each (single res file, multi res file), whether
+            // they are the same object or not, whether the previously written object was deleted.
+
+            if (toWrite == null) {
+                // nothing to write? delete only then.
+                assert previouslyWritten.isRemoved();
+
+                ResourceFile.FileType type = previouslyWritten.getSource().getType();
+
+                if (type == ResourceFile.FileType.SINGLE) {
+                    removeOutFile(rootFolder, previouslyWritten.getSource());
+                } else {
+                    qualifierWithDeletedValues.add(previouslyWritten.getSource().getQualifiers());
+                }
+
+            } else if (previouslyWritten == null || previouslyWritten == toWrite) {
+                // easy one: new or updated res
+
+                writeResource(rootFolder, valuesResMap, toWrite);
+            } else {
+                // replacement of a resource by another.
+
+                // first force the writing of the new one.
+                toWrite.setTouched();
+
+                // write the new value
+                writeResource(rootFolder, valuesResMap, toWrite);
+
+                ResourceFile.FileType previousType = previouslyWritten.getSource().getType();
+                ResourceFile.FileType newType = toWrite.getSource().getType();
+
+                if (previousType == newType) {
+                    // if the type is multi, then we make sure to flag the
+                    // qualifier as deleted.
+                    if (previousType == ResourceFile.FileType.MULTI) {
+                        qualifierWithDeletedValues.add(
+                                previouslyWritten.getSource().getQualifiers());
+                    }
+                } else if (newType == ResourceFile.FileType.SINGLE) {
+                    // new type is single, so old type is multi.
+                    // ensure the previous one is deleted by forcing rewrite of its associated
+                    // qualifiers.
+                    qualifierWithDeletedValues.add(previouslyWritten.getSource().getQualifiers());
+                } else {
+                    // new type is values, and old is single res file.
+                    // delete the old single res file
+                    removeOutFile(rootFolder, previouslyWritten.getSource());
+                }
+            }
+        }
+
+        // now write the values files.
+        for (String key : valuesResMap.keySet()) {
+            // the key is the qualifier.
+
+            // check if we have to write the file due to deleted values.
+            // also remove it from that list anyway (to detect empty qualifiers later).
+            boolean mustWriteFile = qualifierWithDeletedValues.remove(key);
+
+            // get the list of items to write
+            Collection<Resource> items = valuesResMap.get(key);
+
+            // now check if we really have to write it
+            if (!mustWriteFile) {
+                for (Resource item : items) {
+                    if (item.isTouched()) {
+                        mustWriteFile = true;
+                        break;
+                    }
+                }
+            }
+
+            if (mustWriteFile) {
+                String folderName = key.length() > 0 ?
+                        ResourceFolderType.VALUES.getName() + SdkConstants.RES_QUALIFIER_SEP + key :
+                        ResourceFolderType.VALUES.getName();
+
+                File valuesFolder = new File(rootFolder, folderName);
+                valuesFolder.mkdirs();
+                File outFile = new File(valuesFolder, FN_VALUES_XML);
+
+                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+                factory.setNamespaceAware(true);
+                factory.setValidating(false);
+                factory.setIgnoringComments(true);
+                DocumentBuilder builder;
+
+                try {
+                    builder = factory.newDocumentBuilder();
+                    Document document = builder.newDocument();
+
+                    Node rootNode = document.createElement(SdkConstants.TAG_RESOURCES);
+                    document.appendChild(rootNode);
+
+                    for (Resource item : items) {
+                        Node adoptedNode = NodeUtils.adoptNode(document, item.getValue());
+                        rootNode.appendChild(adoptedNode);
+                    }
+
+                    String content = XmlPrettyPrinter.prettyPrint(document);
+
+                    Files.write(content, outFile, Charsets.UTF_8);
+                } catch (ParserConfigurationException e) {
+                    throw new IOException(e);
+                }
+            }
+        }
+
+        // now remove empty values files.
+        for (String key : qualifierWithDeletedValues) {
+            String folderName = key != null && key.length() > 0 ?
+                    ResourceFolderType.VALUES.getName() + SdkConstants.RES_QUALIFIER_SEP + key :
+                    ResourceFolderType.VALUES.getName();
+
+            removeOutFile(rootFolder, folderName, FN_VALUES_XML);
+        }
+    }
+
+    /**
+     * Removes a file that already exists in the out res folder.
+     * @param outFolder the out res folder
+     * @param sourceFile the source file that created the file to remove.
+     * @return true if sucess.
+     */
+    private static boolean removeOutFile(File outFolder, ResourceFile sourceFile) {
+        if (sourceFile.getType() == ResourceFile.FileType.MULTI) {
+            throw new IllegalArgumentException("SourceFile cannot be a FileType.MULTI");
+        }
+
+        File file = sourceFile.getFile();
+        String fileName = file.getName();
+        String folderName = file.getParentFile().getName();
+
+        return removeOutFile(outFolder, folderName, fileName);
+    }
+
+    /**
+     * Removes a file from a folder based on a sub folder name and a filename
+     *
+     * @param outFolder the root folder to remove the file from
+     * @param folderName the sub folder name
+     * @param fileName the file name.
+     * @return true if success.
+     */
+    private static boolean removeOutFile(File outFolder, String folderName, String fileName) {
+        File valuesFolder = new File(outFolder, folderName);
+        File outFile = new File(valuesFolder, fileName);
+        return outFile.delete();
+    }
+
+    /**
+     * Writes a given Resource to a given root res folder.
+     * If the Resource is to be written in a "Values" folder, then it is added to a map instead.
+     *
+     * @param rootFolder the root res folder
+     * @param valuesResMap a map of existing values-type resources where the key is the qualifiers
+     *                     of the values folder.
+     * @param resource the resource to add.
+     * @throws IOException
+     */
+    private void writeResource(File rootFolder, ListMultimap<String, Resource> valuesResMap,
+                               Resource resource) throws IOException {
+        ResourceFile.FileType type = resource.getSource().getType();
+
+        if (type == ResourceFile.FileType.MULTI) {
+            // this is a resource for the values files
+
+            // just add the node to write to the map based on the qualifier.
+            // We'll figure out later if the files needs to be written or (not)
+
+            String qualifier = resource.getSource().getQualifiers();
+            if (qualifier == null) {
+                qualifier = "";
+            }
+
+            valuesResMap.put(qualifier, resource);
+        } else {
+            // This is a single value file.
+            // Only write it if the state is TOUCHED.
+            if (resource.isTouched()) {
+                ResourceFile resourceFile = resource.getSource();
+                File file = resourceFile.getFile();
+
+                String filename = file.getName();
+                String folderName = resource.getType().getName();
+                String qualifiers = resourceFile.getQualifiers();
+                if (qualifiers != null && qualifiers.length() > 0) {
+                    folderName = folderName + SdkConstants.RES_QUALIFIER_SEP + qualifiers;
+                }
+
+                File typeFolder = new File(rootFolder, folderName);
+                if (!typeFolder.isDirectory()) {
+                    typeFolder.mkdirs();
+                }
+
+                File outFile = new File(typeFolder, filename);
+                Files.copy(file, outFile);
+            }
+        }
+    }
+
+    /**
+     * Writes a single blog file to store all that the ResourceMerger knows about.
+     *
+     * @param blobRootFolder the root folder where blobs are store.
+     * @throws java.io.IOException
+     *
+     * @see #loadFromBlob(java.io.File)
+     */
+    public void writeBlobTo(File blobRootFolder) throws IOException {
+        // write "compact" blob
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setNamespaceAware(true);
+        factory.setValidating(false);
+        factory.setIgnoringComments(true);
+        DocumentBuilder builder;
+
+        try {
+            builder = factory.newDocumentBuilder();
+            Document document = builder.newDocument();
+
+            Node rootNode = document.createElement(NODE_MERGER);
+            document.appendChild(rootNode);
+
+            for (ResourceSet resourceSet : mResourceSets) {
+                Node resourceSetNode = document.createElement(NODE_RESOURCE_SET);
+                rootNode.appendChild(resourceSetNode);
+
+                resourceSet.appendToXml(resourceSetNode, document);
+            }
+
+            String content = XmlPrettyPrinter.prettyPrint(document);
+
+            blobRootFolder.mkdirs();
+            Files.write(content, new File(blobRootFolder, FN_MERGER_XML), Charsets.UTF_8);
+        } catch (ParserConfigurationException e) {
+            throw new IOException(e);
+        }
+    }
+
+    /**
+     * Loads the merger state from a blob file.
+     *
+     * @param blobRootFolder the folder containing the blob.
+     * @return
+     * @throws IOException
+     *
+     * @see #writeBlobTo(java.io.File)
+     */
+    public boolean loadFromBlob(File blobRootFolder) throws IOException {
+        File file = new File(blobRootFolder, FN_MERGER_XML);
+        if (!file.isFile()) {
+            return false;
+        }
+
+        BufferedInputStream stream = null;
+        try {
+            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+            stream = new BufferedInputStream(new FileInputStream(file));
+            InputSource is = new InputSource(stream);
+            factory.setNamespaceAware(true);
+            factory.setValidating(false);
+
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            Document document = builder.parse(is);
+
+            // get the root node
+            Node rootNode = document.getDocumentElement();
+            if (rootNode == null || !NODE_MERGER.equals(rootNode.getLocalName())) {
+                return false;
+            }
+
+            NodeList nodes = rootNode.getChildNodes();
+
+            for (int i = 0, n = nodes.getLength(); i < n; i++) {
+                Node node = nodes.item(i);
+
+                if (node.getNodeType() != Node.ELEMENT_NODE ||
+                        !NODE_RESOURCE_SET.equals(node.getLocalName())) {
+                    continue;
+                }
+
+                ResourceSet resourceSet = ResourceSet.createFromXml(node);
+                if (resourceSet != null) {
+                    mResourceSets.add(resourceSet);
+                }
+            }
+
+            setResourcesToWritten();
+
+            return true;
+        } catch (FileNotFoundException e) {
+            throw new IOException(e);
+        } catch (ParserConfigurationException e) {
+            throw new IOException(e);
+        } catch (SAXException e) {
+            throw new IOException(e);
+        } finally {
+            try {
+                if (stream != null) {
+                    stream.close();
+                }
+            } catch (IOException e) {
+                // ignore
+            }
+        }
+    }
+
+    /**
+     * Sets all existing resources to have their state be WRITTEN.
+     *
+     * @see com.android.builder.resources.Resource#isWritten()
+     */
+    private void setResourcesToWritten() {
+        ListMultimap<String, Resource> resources = ArrayListMultimap.create();
+
+        for (ResourceSet resourceSet : mResourceSets) {
+            ListMultimap<String, Resource> map = resourceSet.getResourceMap();
+            for (Map.Entry<String, Collection<Resource>> entry : map.asMap().entrySet()) {
+                resources.putAll(entry.getKey(), entry.getValue());
+            }
+        }
+
+        for (String key : resources.keySet()) {
+            List<Resource> resourceList = resources.get(key);
+            resourceList.get(resourceList.size() - 1).resetStatusToWritten();
+        }
+    }
+
+    /**
+     * Checks that a loaded merger can be updated with a given list of ResourceSet.
+     *
+     * For now this means the sets haven't changed.
+     *
+     * @param resourceSets the resource sets.
+     * @return true if the update can be performed. false if a full merge should be done.
+     */
+    public boolean checkValidUpdate(List<ResourceSet> resourceSets) {
+        if (resourceSets.size() != mResourceSets.size()) {
+            return false;
+        }
+
+        for (int i = 0, n = resourceSets.size(); i < n; i++) {
+            ResourceSet localSet = mResourceSets.get(i);
+            ResourceSet newSet = resourceSets.get(i);
+
+            List<File> localSourceFiles = localSet.getSourceFiles();
+            List<File> newSourceFiles = newSet.getSourceFiles();
+
+            // compare the config name and source files sizes.
+            if (!newSet.getConfigName().equals(localSet.getConfigName()) ||
+                    localSourceFiles.size() != newSourceFiles.size()) {
+                return false;
+            }
+
+            // compare the source files. The order is not important so it should be normalized
+            // before it's compared.
+            // make copies to sort.
+            localSourceFiles = Lists.newArrayList(localSourceFiles);
+            Collections.sort(localSourceFiles);
+            newSourceFiles = Lists.newArrayList(newSourceFiles);
+            Collections.sort(newSourceFiles);
+
+            if (!localSourceFiles.equals(newSourceFiles)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns a ResourceSet that contains a given file.
+     *
+     * "contains" means that the ResourceSet has a source file/folder that is the root folder
+     * of this file. The folder and/or file doesn't have to exist.
+     *
+     * @param file the file to check
+     * @return a pair containing the ResourceSet and its source file that contains the file.
+     */
+    public Pair<ResourceSet, File> getResourceSetContaining(File file) {
+        for (ResourceSet resourceSet : mResourceSets) {
+            File sourceFile = resourceSet.findMatchingSourceFile(file);
+            if (file != null) {
+                return Pair.of(resourceSet, sourceFile);
+            }
+        }
+
+        return null;
     }
 }
diff --git a/builder/src/main/java/com/android/builder/resources/ResourceSet.java b/builder/src/main/java/com/android/builder/resources/ResourceSet.java
index dcc2a93..20a08b4 100644
--- a/builder/src/main/java/com/android/builder/resources/ResourceSet.java
+++ b/builder/src/main/java/com/android/builder/resources/ResourceSet.java
@@ -16,236 +16,141 @@
 
 package com.android.builder.resources;
 
-import com.android.SdkConstants;
+import com.android.annotations.NonNull;
 import com.android.resources.FolderTypeRelationship;
 import com.android.resources.ResourceConstants;
 import com.android.resources.ResourceFolderType;
 import com.android.resources.ResourceType;
-import com.android.utils.XmlUtils;
-import com.google.common.base.Charsets;
 import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
-import com.google.common.io.Files;
-import com.sun.xml.internal.rngom.ast.builder.BuildException;
 import org.w3c.dom.Attr;
 import org.w3c.dom.Document;
-import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
 /**
- * Represents a set of resources at the same level (not overlay) coming from different sources
- * (folders or resource bundles)
+ * Represents a set of resources.
+ *
+ * The resources can be coming from multiple source folders. Duplicates are detected (either
+ * from the same source folder -- same resource in values files -- or across the source folders.
+ *
+ * Each source folders is considered to be at the same level. To use overlays, a
+ * {@link ResourceMerger} must be used.
+ *
+ * Creating the set and adding folders does not load the data.
+ * The data can be loaded from the files, or from a blob which is generated by the set itself.
+ *
+ * Upon loading the data from the blob, the data can be updated with fresher files. Each resource
+ * that is updated is flagged as such, in order to manage incremental update.
+ *
+ * Writing/Loading the blob is not done through this class directly, but instead through the
+ * {@link ResourceMerger} which contains ResourceSet objects.
  */
-public class ResourceSet {
+public class ResourceSet implements SourceSet, ResourceMap {
+
+    private static final String NODE_SOURCE = "source";
+    private static final String ATTR_CONFIG = "config";
+    private static final String ATTR_PATH = "path";
+    private static final String NODE_FILE = "file";
+    private static final String ATTR_QUALIFIER = "qualifiers";
+    private static final String ATTR_TYPE = "type";
+    private static final String ATTR_NAME = "name";
+
+    private final String mConfigName;
+
+    /**
+     * List of source files. The may not have been loaded yet.
+     */
+    private final List<File> mSourceFiles = Lists.newArrayList();
 
     /**
      * The key is the {@link com.android.builder.resources.Resource#getKey()}.
+     * This is a multimap to support moving a resource from one file to another (values file)
+     * during incremental update.
      */
-    private final Map<String, Resource> mItems = Maps.newHashMap();
+    private final ListMultimap<String, Resource> mItems = ArrayListMultimap.create();
 
-    public ResourceSet() {
-        // nothing done here
-    }
+    /**
+     * Map of source files to ResourceFiles. This is a multimap because the key is the source
+     * file/folder, not the
+     * File for the resource file itself.
+     */
+    private final ListMultimap<File, ResourceFile> mSourceFileToResourceFilesMap = ArrayListMultimap.create();
+    /**
+     * Map from a File to its ResourceFile.
+     */
+    private final Map<File, ResourceFile> mResourceFileMap = Maps.newHashMap();
 
-    ResourceSet(Map<String, Resource> items) {
-        mItems.putAll(items);
-    }
-
-    public void addSource(File file) throws DuplicateResourceException {
-        if (file.isDirectory()) {
-            readFolder(file);
-
-        } else if (file.isFile()) {
-            // TODO
-        }
-    }
-
-    public int getSize() {
-        return mItems.size();
-    }
-
-    public boolean isEmpty() {
-        return mItems.isEmpty();
-    }
-
-    public Collection<Resource> getResources() {
-        return mItems.values();
-    }
-
-    public Map<String, Resource> getResourceMap() {
-        return mItems;
-    }
-
-    public void writeTo(File rootFolder) throws IOException {
-        // map of XML values files to write after parsing all the files.
-        // the key is the qualifier.
-        Multimap<String, Resource> map = ArrayListMultimap.create();
-
-        for (Resource item : mItems.values()) {
-            if (item.getValue() != null) {
-                String qualifier = item.getSource().getQualifiers();
-                if (qualifier == null) {
-                    qualifier = "";
-                }
-
-                map.put(qualifier, item);
-            } else {
-                // we can write the file.
-                ResourceFile resourceFile = item.getSource();
-                File file = resourceFile.getFile();
-
-                String filename = file.getName();
-                String folderName = item.getType().getName();
-                String qualifiers = resourceFile.getQualifiers();
-                if (qualifiers != null && qualifiers.length() > 0) {
-                    folderName = folderName + SdkConstants.RES_QUALIFIER_SEP + qualifiers;
-                }
-
-                File typeFolder = new File(rootFolder, folderName);
-                if (!typeFolder.isDirectory()) {
-                    typeFolder.mkdirs();
-                }
-
-                File outFile = new File(typeFolder, filename);
-                Files.copy(file, outFile);
-            }
-        }
-
-        // now write the values files.
-        for (String key : map.keySet()) {
-            // the key is the qualifier.
-            String folderName = key.length() > 0 ?
-                    ResourceFolderType.VALUES.getName() + SdkConstants.RES_QUALIFIER_SEP + key :
-                    ResourceFolderType.VALUES.getName();
-
-            File valuesFolder = new File(rootFolder, folderName);
-            valuesFolder.mkdirs();
-            File outFile = new File(valuesFolder, "values.xml");
-
-            // get the list of items to write
-            Collection<Resource> items = map.get(key);
-
-            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-            factory.setNamespaceAware(true);
-            factory.setValidating(false);
-            factory.setIgnoringComments(true);
-            DocumentBuilder builder;
-
-            try {
-                builder = factory.newDocumentBuilder();
-                Document document = builder.newDocument();
-
-                Node rootNode = document.createElement(SdkConstants.TAG_RESOURCES);
-                document.appendChild(rootNode);
-
-                for (Resource item : items) {
-                    Node adoptedNode = adoptNode(document, item.getValue());
-                    rootNode.appendChild(adoptedNode);
-                }
-
-                String content = XmlUtils.toXml(document, false /*preserveWhitespace*/);
-
-                Files.write(content, outFile, Charsets.UTF_8);
-            } catch (ParserConfigurationException e) {
-                throw new BuildException(e);
-            }
-        }
+    /**
+     * Creates a resource set with a given configName. The name is used to identify the set
+     * across sessions.
+     *
+     * @param configName the name of the config this set is associated with.
+     */
+    public ResourceSet(String configName) {
+        mConfigName = configName;
     }
 
     /**
-     * Makes a new document adopt a node from a different document, and correctly reassign namespace
-     * and prefix
-     * @param document the new document
-     * @param node the node to adopt.
-     * @return the adopted node.
+     * Adds a collection of source files.
+     * @param files the source files to add.
      */
-    private Node adoptNode(Document document, Node node) {
-        Node newNode = document.adoptNode(node);
-
-        updateNamespace(newNode, document);
-
-        return newNode;
+    public void addSources(Collection<File> files) {
+        mSourceFiles.addAll(files);
     }
 
     /**
-     * Updates the namespace of a given node (and its children) to work in a given document
-     * @param node the node to update
-     * @param document the new document
+     * Adds a new source file
+     * @param file the source file.
      */
-    private void updateNamespace(Node node, Document document) {
-
-        // first process this node
-        processSingleNodeNamespace(node, document);
-
-        // then its attributes
-        NamedNodeMap attributes = node.getAttributes();
-        if (attributes != null) {
-            for (int i = 0, n = attributes.getLength(); i < n; i++) {
-                processSingleNodeNamespace(attributes.item(i), document);
-            }
-        }
-
-        // then do it for the children nodes.
-        NodeList children = node.getChildNodes();
-        if (children != null) {
-            for (int i = 0, n = children.getLength(); i < n; i++) {
-                Node child = children.item(i);
-                if (child != null) {
-                    updateNamespace(child, document);
-                }
-            }
-        }
+    public void addSource(File file) {
+        mSourceFiles.add(file);
     }
 
     /**
-     * Update the namespace of a given node to work with a given document.
-     * @param node the node to update
-     * @param document the new document
+     * Get the list of source files.
+     * @return the source files.
      */
-    private void processSingleNodeNamespace(Node node, Document document) {
-        String ns = node.getNamespaceURI();
-        if (ns != null) {
-            NamedNodeMap docAttributes = document.getAttributes();
-
-            String prefix = getPrefixForNs(docAttributes, ns);
-            if (prefix == null) {
-                prefix = getUniqueNsAttribute(docAttributes);
-                Attr nsAttr = document.createAttribute(prefix);
-                nsAttr.setValue(ns);
-                document.getChildNodes().item(0).getAttributes().setNamedItem(nsAttr);
-            }
-
-            // set the prefix on the node, by removing the xmlns: start
-            prefix = prefix.substring(6);
-            node.setPrefix(prefix);
-        }
+    @NonNull
+    @Override
+    public List<File> getSourceFiles() {
+        return mSourceFiles;
     }
 
     /**
-     * Looks for an existing prefix for a a given namespace.
-     * The prefix must start with "xmlns:". The whole prefix is returned.
-     * @param attributes the list of attributes to look through
-     * @param ns the namespace to find.
-     * @return the found prefix or null if none is found.
+     * Returns the config name.
+     * @return the config name.
      */
-    private String getPrefixForNs(NamedNodeMap attributes, String ns) {
-        if (attributes != null) {
-            for (int i = 0, n = attributes.getLength(); i < n; i++) {
-                Attr attribute = (Attr) attributes.item(i);
-                if (ns.equals(attribute.getValue()) && ns.startsWith(SdkConstants.XMLNS_PREFIX)) {
-                    return attribute.getName();
+    public String getConfigName() {
+        return mConfigName;
+    }
+
+    /**
+     * Returns a matching Source file that contains a given file.
+     *
+     * "contains" means that the source file/folder is the root folder
+     * of this file. The folder and/or file doesn't have to exist.
+     *
+     * @param file the file to search for
+     * @return the Source file or null if no match is found.
+     */
+    @Override
+    public File findMatchingSourceFile(File file) {
+        for (File sourceFile : mSourceFiles) {
+            if (sourceFile.equals(file)) {
+                return sourceFile;
+            } else if (sourceFile.isDirectory()) {
+                String sourcePath = sourceFile.getAbsolutePath() + File.separator;
+                if (file.getAbsolutePath().startsWith(sourcePath)) {
+                    return sourceFile;
                 }
             }
         }
@@ -253,87 +158,482 @@
         return null;
     }
 
-    private String getUniqueNsAttribute(NamedNodeMap attributes) {
-        if (attributes == null) {
-            return "xmlns:ns1";
-        }
-
-        int i = 2;
-        while (true) {
-            String name = String.format("xmlns:ns%d", i++);
-            if (attributes.getNamedItem(name) == null) {
-                return name;
-            }
-        }
+    /**
+     * Returns the number of resources.
+     * @return the number of resources.
+     *
+     * @see ResourceMap
+     */
+    @Override
+    public int size() {
+        // returns the number of keys, not the size of the multimap which would include duplicate
+        // Resource objects.
+        return mItems.keySet().size();
     }
 
-    private void readFolder(File rootFolder) throws DuplicateResourceException {
-        File[] folders = rootFolder.listFiles();
-        if (folders != null) {
-            for (File folder : folders) {
-                if (folder.isDirectory()) {
-                    parseFolder(folder);
+    /**
+     * Returns whether the set is empty of resources.
+     * @return true if the set contains no resources.
+     */
+    public boolean isEmpty() {
+        return mItems.isEmpty();
+    }
+
+    /**
+     * Returns a map of the resources.
+     * @return a map of items.
+     *
+     * @see ResourceMap
+     */
+    @NonNull
+    @Override
+    public ListMultimap<String, Resource> getResourceMap() {
+        return mItems;
+    }
+
+    /**
+     * Loads the resource set from the file its source folder contains.
+     *
+     * All loaded resources are set to TOUCHED. This is so that after loading the resources from
+     * the files, they can be written directly (since touched force them to be written).
+     *
+     * This also checks for duplicates resources.
+     *
+     * @throws DuplicateResourceException
+     * @throws IOException
+     */
+    public void loadFromFiles() throws DuplicateResourceException, IOException {
+        for (File file : mSourceFiles) {
+            if (file.isDirectory()) {
+                readSourceFolder(file);
+
+            } else if (file.isFile()) {
+                // TODO support resource bundle
+            }
+        }
+        checkItems();
+    }
+
+    /**
+     * Appends the resourceSet to a given DOM object.
+     *
+     * @param resourceSetNode the root node for this resource set.
+     * @param document The root XML document
+     */
+    void appendToXml(Node resourceSetNode, Document document) {
+        // add the config name attribute
+        NodeUtils.addAttribute(document, resourceSetNode, null, ATTR_CONFIG, mConfigName);
+
+        // add the source files.
+        // we need to loop on the source files themselves and not the map to ensure we
+        // write empty resourceSets
+        for (File sourceFile : mSourceFiles) {
+
+            // the node for the source and its path attribute
+            Node sourceNode = document.createElement(NODE_SOURCE);
+            resourceSetNode.appendChild(sourceNode);
+            NodeUtils.addAttribute(document, sourceNode, null, ATTR_PATH,
+                    sourceFile.getAbsolutePath());
+
+            Collection<ResourceFile> resourceFiles = mSourceFileToResourceFilesMap.get(sourceFile);
+
+            for (ResourceFile resourceFile : resourceFiles) {
+                // the node for the file and its path and qualifiers attribute
+                Node fileNode = document.createElement(NODE_FILE);
+                sourceNode.appendChild(fileNode);
+                NodeUtils.addAttribute(document, fileNode, null, ATTR_PATH,
+                        resourceFile.getFile().getAbsolutePath());
+                NodeUtils.addAttribute(document, fileNode, null, ATTR_QUALIFIER,
+                        resourceFile.getQualifiers());
+
+                if (resourceFile.getType() == ResourceFile.FileType.MULTI) {
+                    for (Resource item : resourceFile.getItems()) {
+                        Node adoptedNode = NodeUtils.adoptNode(document, item.getValue());
+                        fileNode.appendChild(adoptedNode);
+                    }
+                } else {
+                    Resource item = resourceFile.getItem();
+                    NodeUtils.addAttribute(document, fileNode, null, ATTR_TYPE,
+                            item.getType().getName());
+                    NodeUtils.addAttribute(document, fileNode, null, ATTR_NAME, item.getName());
                 }
             }
         }
     }
 
-    private void parseFolder(File folder) throws DuplicateResourceException {
+    /**
+     * Creates a new ResourceSet from an XML node that was created with
+     * {@link #appendToXml(org.w3c.dom.Node, org.w3c.dom.Document)}
+     *
+     * @param resourceSetNode the node to read from.
+     * @return a new ResourceSet object or null.
+     */
+    static ResourceSet createFromXml(Node resourceSetNode) {
+        // get the config name
+        Attr configNameAttr = (Attr) resourceSetNode.getAttributes().getNamedItem(ATTR_CONFIG);
+        if (configNameAttr == null) {
+            return null;
+        }
 
-        // get the type.
+        // create the ResourceSet that will be filled with the content of the XML.
+        ResourceSet resourceSet = new ResourceSet(configNameAttr.getValue());
+
+        // loop on the source nodes
+        NodeList sourceNodes = resourceSetNode.getChildNodes();
+        for (int i = 0, n = sourceNodes.getLength(); i < n; i++) {
+            Node sourceNode = sourceNodes.item(i);
+
+            if (sourceNode.getNodeType() != Node.ELEMENT_NODE ||
+                    !NODE_SOURCE.equals(sourceNode.getLocalName())) {
+                continue;
+            }
+
+            Attr pathAttr = (Attr) sourceNode.getAttributes().getNamedItem(ATTR_PATH);
+            if (pathAttr == null) {
+                continue;
+            }
+
+            File sourceFolder = new File(pathAttr.getValue());
+            resourceSet.mSourceFiles.add(sourceFolder);
+
+            // now loop on the files inside the source folder.
+            NodeList fileNodes = sourceNode.getChildNodes();
+            for (int j = 0, m = fileNodes.getLength(); j < m; j++) {
+                Node fileNode = fileNodes.item(j);
+
+                if (fileNode.getNodeType() != Node.ELEMENT_NODE ||
+                        !NODE_FILE.equals(fileNode.getLocalName())) {
+                    continue;
+                }
+
+                pathAttr = (Attr) fileNode.getAttributes().getNamedItem(ATTR_PATH);
+                if (pathAttr == null) {
+                    continue;
+                }
+
+                Attr qualifierAttr = (Attr) fileNode.getAttributes().getNamedItem(ATTR_QUALIFIER);
+                String qualifier = qualifierAttr != null ? qualifierAttr.getValue() : null;
+
+                Attr typeAttr = (Attr) fileNode.getAttributes().getNamedItem(ATTR_TYPE);
+                if (typeAttr == null) {
+                    // multi res file
+                    List<Resource> resourceList = Lists.newArrayList();
+
+                    // loop on each node that represent a resource
+                    NodeList resNodes = fileNode.getChildNodes();
+                    for (int iii = 0, nnn = resNodes.getLength(); iii < nnn; iii++) {
+                        Node resNode = resNodes.item(iii);
+
+                        if (resNode.getNodeType() != Node.ELEMENT_NODE) {
+                            continue;
+                        }
+
+                        Resource r = ValueResourceParser.getResource(resNode);
+                        if (r != null) {
+                            resourceList.add(r);
+                        }
+                    }
+
+                    ResourceFile resourceFile = new ResourceFile(new File(pathAttr.getValue()),
+                            resourceList, qualifier);
+                    resourceSet.addResourceFile(sourceFolder, resourceFile);
+
+                    for (Resource item : resourceList) {
+                        resourceSet.mItems.put(item.getKey(), item);
+                    }
+
+                } else {
+                    // single res file
+                    ResourceType type = ResourceType.getEnum(typeAttr.getValue());
+                    if (type == null) {
+                        continue;
+                    }
+
+                    Attr nameAttr = (Attr) fileNode.getAttributes().getNamedItem(ATTR_NAME);
+                    if (nameAttr == null) {
+                        continue;
+                    }
+
+                    Resource item = new Resource(nameAttr.getValue(), type, null);
+                    ResourceFile resourceFile = new ResourceFile(new File(pathAttr.getValue()),
+                            item, qualifier);
+
+                    resourceSet.addResourceFile(sourceFolder, resourceFile);
+                    resourceSet.mItems.put(item.getKey(), item);
+                }
+            }
+        }
+
+        return resourceSet;
+    }
+
+    /**
+     * Reads the content of a resource folders and loads the resources.
+     * @param sourceFolder the source folder to load the resources from.
+     *
+     * @throws DuplicateResourceException
+     * @throws IOException
+     */
+    private void readSourceFolder(File sourceFolder)
+            throws DuplicateResourceException, IOException {
+        File[] folders = sourceFolder.listFiles();
+        if (folders != null) {
+            for (File folder : folders) {
+                if (folder.isDirectory()) {
+                    parseFolder(sourceFolder, folder);
+                }
+            }
+        }
+    }
+
+    /**
+     * temp structure containing a qualifier string and a {@link ResourceType}.
+     */
+    private static class FolderData {
+        String qualifiers = null;
+        ResourceType type = null;
+    }
+
+    /**
+     * Returns a FolderData for the given folder
+     * @param folder the folder.
+     * @return the FolderData object.
+     */
+    @NonNull
+    private static FolderData getFolderData(File folder) {
+        FolderData fd = new FolderData();
+
         String folderName = folder.getName();
         int pos = folderName.indexOf(ResourceConstants.RES_QUALIFIER_SEP);
         ResourceFolderType folderType;
-        String qualifiers = null;
         if (pos != -1) {
             folderType = ResourceFolderType.getTypeByName(folderName.substring(0, pos));
-            qualifiers = folderName.substring(pos + 1);
+            fd.qualifiers = folderName.substring(pos + 1);
         } else {
             folderType = ResourceFolderType.getTypeByName(folderName);
         }
 
-        boolean singleResourceFile = folderType != ResourceFolderType.VALUES;
-        List<ResourceType> types = FolderTypeRelationship.getRelatedResourceTypes(folderType);
+        if (folderType != ResourceFolderType.VALUES) {
+            fd.type = FolderTypeRelationship.getRelatedResourceTypes(folderType).get(0);
+        }
+
+        return fd;
+    }
+
+    /**
+     * Reads the content of a typed resource folder (sub folder to the root of res folder), and
+     * loads the resources from it.
+     *
+     * @param sourceFolder the main res folder
+     * @param folder the folder to read.
+     *
+     * @throws IOException
+     */
+    private void parseFolder(File sourceFolder, File folder)
+            throws IOException {
+        // get the type.
+        FolderData folderData = getFolderData(folder);
 
         // get the files
         File[] files = folder.listFiles();
         if (files != null && files.length > 0) {
             for (File file : files) {
-                if (singleResourceFile) {
-                    // get the resource name based on the filename
-                    String name = file.getName();
-                    pos = name.indexOf('.');
-                    name = name.substring(0, pos);
-
-                    Resource item = new Resource(name, types.get(0), null);
-                    ResourceFile resourceFile = new ResourceFile(file, item, qualifiers);
-
-                    checkItem(item);
-
-                    mItems.put(item.getKey(), item);
+                if (folderData.type != null) {
+                    Resource item = handleSingleResFile(sourceFolder,
+                            folderData.qualifiers, folderData.type, file);
+                    item.setTouched();
                 } else {
-                    ValueResourceParser parser = new ValueResourceParser(file);
-                    try {
-                        List<Resource> items = parser.parseFile();
-
-                        ResourceFile resourceFile = new ResourceFile(file, items, qualifiers);
-
-                        for (Resource item : items) {
-                            checkItem(item);
-                            mItems.put(item.getKey(), item);
-                        }
-                    } catch (FileNotFoundException e) {
-                        // wont happen as we know the file exists.
+                    Collection<Resource> items = handleMultiResFile(sourceFolder,
+                            folderData.qualifiers, file);
+                    for (Resource item : items) {
+                        item.setTouched();
                     }
                 }
             }
         }
     }
 
-    private void checkItem(Resource item) throws DuplicateResourceException {
-        Resource otherItem = mItems.get(item.getKey());
-        if (otherItem != null) {
-            throw new DuplicateResourceException(item, otherItem);
+    /**
+     * Handles a single resource file (ie not located in "values") and create a Resource from it.
+     *
+     * @param sourceFolder the top res folder for the file
+     * @param qualifiers the qualifiers associated with the file
+     * @param type the ResourceType read from the parent folder name
+     * @param file the single resource file
+     * @return a Resource object
+     */
+    @NonNull
+    private Resource handleSingleResFile(File sourceFolder, String qualifiers,
+                                         ResourceType type, File file) {
+        int pos;// get the resource name based on the filename
+        String name = file.getName();
+        pos = name.indexOf('.');
+        name = name.substring(0, pos);
+
+        Resource item = new Resource(name, type, null);
+        ResourceFile resourceFile = new ResourceFile(file, item, qualifiers);
+        addResourceFile(sourceFolder, resourceFile);
+
+        mItems.put(item.getKey(), item);
+
+        return item;
+    }
+
+    /**
+     * Handles a multi res file (in a "values" folder) and create Resource object from it.
+     *
+     * @param sourceFolder the top res folder for the file
+     * @param qualifiers the qualifiers associated with the file
+     * @param file the single resource file
+     * @return a list of created Resource objects.
+     *
+     * @throws IOException
+     */
+    @NonNull
+    private Collection<Resource> handleMultiResFile(File sourceFolder, String qualifiers, File file)
+            throws IOException {
+        ValueResourceParser parser = new ValueResourceParser(file);
+        List<Resource> items = parser.parseFile();
+
+        ResourceFile resourceFile = new ResourceFile(file, items, qualifiers);
+        addResourceFile(sourceFolder, resourceFile);
+
+        for (Resource item : items) {
+            mItems.put(item.getKey(), item);
         }
+
+        return items;
+    }
+
+    /**
+     * Adds a new ResourceFile to this.
+     *
+     * @param sourceFile the parent source file.
+     * @param resourceFile the ResourceFile
+     */
+    private void addResourceFile(File sourceFile, ResourceFile resourceFile) {
+        mSourceFileToResourceFilesMap.put(sourceFile, resourceFile);
+        mResourceFileMap.put(resourceFile.getFile(), resourceFile);
+    }
+
+    /**
+     * Checks for duplicate resources across all source files.
+     *
+     * @throws DuplicateResourceException if a duplicated item is found.
+     */
+    void checkItems() throws DuplicateResourceException {
+        // check a list for duplicate, ignoring removed items.
+        for (Map.Entry<String, Collection<Resource>> entry : mItems.asMap().entrySet()) {
+            Collection<Resource> items = entry.getValue();
+
+            // there can be several version of the same key if some are "removed"
+            Resource lastItem = null;
+            for (Resource item : items) {
+                if (!item.isRemoved()) {
+                    if (lastItem == null) {
+                        lastItem = item;
+                    } else {
+                        throw new DuplicateResourceException(item, lastItem);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Update the ResourceSet with a given file.
+     *
+     * @param sourceFolder the sourceFile containing the changedFile
+     * @param changedFile The changed file
+     * @param fileStatus the change state
+     * @return true if the set was properly updated, false otherwise
+     */
+    public boolean updateWith(File sourceFolder, File changedFile, FileStatus fileStatus)
+            throws IOException {
+        switch (fileStatus) {
+            case CHANGED:
+                FolderData folderData = getFolderData(changedFile.getParentFile());
+                ResourceFile resourceFile = mResourceFileMap.get(changedFile);
+
+                if (folderData.type != null) {
+                    // single res file
+                    resourceFile.getItem().setTouched();
+                } else {
+                    // multi res. Need to parse the file and compare the items one by one.
+                    ValueResourceParser parser = new ValueResourceParser(changedFile);
+                    List<Resource> parsedItems = parser.parseFile();
+
+                    Map<String, Resource> oldItems = Maps.newHashMap(resourceFile.getItemMap());
+
+                    Map<String, Resource> newItems  = Maps.newHashMap();
+
+                    // create a fake ResourceFile to be able to call resource.getKey();
+                    // It's ok because we never use this instance anyway.
+                    ResourceFile fakeResourceFile = new ResourceFile(changedFile, parsedItems,
+                            resourceFile.getQualifiers());
+
+                    for (Resource newItem : parsedItems) {
+                        String newKey = newItem.getKey();
+                        Resource oldItem = oldItems.get(newKey);
+
+                        if (oldItem == null) {
+                            // this is a new item
+                            newItems.put(newKey, newItem.setTouched());
+                        } else {
+                            // remove it from the list of oldItems (this is to detect deletion)
+                            //noinspection SuspiciousMethodCalls
+                            oldItems.remove(oldItem.getKey());
+
+                            // now compare the items
+                            if (!oldItem.compareValueWith(newItem)) {
+                                // if the values are different, take the values from the newItems
+                                // and update the old item status.
+
+                                oldItem.setValue(newItem);
+                            }
+                        }
+                    }
+
+                    // at this point oldItems is left with the deleted items.
+                    // just update their status to removed.
+                    for (Resource deletedItem : oldItems.values()) {
+                        deletedItem.setRemoved();
+                    }
+
+                    // Now we need to add the new items to the resource file and the main map
+                    resourceFile.addItems(newItems.values());
+                    for (Map.Entry<String, Resource> entry : newItems.entrySet()) {
+                        mItems.put(entry.getKey(), entry.getValue());
+                    }
+                }
+
+                return true;
+            case NEW:
+                folderData = getFolderData(changedFile.getParentFile());
+
+                if (folderData.type != null) {
+                    Resource item = handleSingleResFile(sourceFolder, folderData.qualifiers,
+                            folderData.type, changedFile);
+                    item.setTouched();
+                } else {
+                    Collection<Resource> items = handleMultiResFile(sourceFolder,
+                            folderData.qualifiers, changedFile);
+                    for (Resource item : items) {
+                        item.setTouched();
+                    }
+                }
+
+                return true;
+            case REMOVED:
+                resourceFile = mResourceFileMap.get(changedFile);
+
+                // flag all resource items are removed
+                for (Resource item : resourceFile.getItems()) {
+                    item.setRemoved();
+                }
+                return true;
+        }
+
+        return false;
     }
 }
diff --git a/builder/src/main/java/com/android/builder/resources/SourceSet.java b/builder/src/main/java/com/android/builder/resources/SourceSet.java
new file mode 100644
index 0000000..f7e6fff
--- /dev/null
+++ b/builder/src/main/java/com/android/builder/resources/SourceSet.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2012 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.builder.resources;
+
+import com.android.annotations.NonNull;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * A Source sets that contains a list of source files/folders
+ */
+public interface SourceSet {
+
+    /**
+     * Returns a list of Source files or folders.
+     * @return a non null list.
+     */
+    @NonNull
+    List<File> getSourceFiles();
+
+    /**
+     * Finds and returns a Source file/folder containing a given file.
+     *
+     * It doesn't actually check if the file exists, instead just cares about the file path.
+     *
+     * @param file the file to search for
+     * @return the source file containing the file or null if none are found.
+     */
+    File findMatchingSourceFile(File file);
+}
diff --git a/builder/src/main/java/com/android/builder/resources/ValueResourceParser.java b/builder/src/main/java/com/android/builder/resources/ValueResourceParser.java
index 99b8c7d..fd1b0ec 100644
--- a/builder/src/main/java/com/android/builder/resources/ValueResourceParser.java
+++ b/builder/src/main/java/com/android/builder/resources/ValueResourceParser.java
@@ -16,41 +16,54 @@
 
 package com.android.builder.resources;
 
+import com.android.annotations.NonNull;
 import com.android.resources.ResourceType;
 import com.google.common.collect.Lists;
-import com.sun.xml.internal.rngom.ast.builder.BuildException;
 import org.w3c.dom.Attr;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 
-import static com.android.SdkConstants.ATTR_NAME;
-import static com.android.SdkConstants.ATTR_TYPE;
-import static com.android.SdkConstants.TAG_ITEM;
+import static com.android.SdkConstants.*;
 
 /**
+ * Parser for "values" files.
+ *
+ * This parses the file and returns a list of {@link Resource} object.
  */
 class ValueResourceParser {
 
     private final File mFile;
 
+    /**
+     * Creates the parser for a given file.
+     * @param file the file to parse.
+     */
     ValueResourceParser(File file) {
         mFile = file;
     }
 
-    List<Resource> parseFile() throws FileNotFoundException {
-        Document document = parseDocument();
+    /**
+     * Parses the file and returns a list of {@link Resource} objects.
+     * @return a list of resources.
+     *
+     * @throws IOException
+     */
+    @NonNull
+    List<Resource> parseFile() throws IOException {
+        Document document = parseDocument(mFile);
 
         // get the root node
         Node rootNode = document.getDocumentElement();
@@ -68,19 +81,37 @@
                 continue;
             }
 
-            ResourceType type = getType(node);
-            String name = getName(node);
-
-            if (type != null && name != null) {
-                Resource r = new Resource(name, type, node);
-                resources.add(r);
+            Resource resource = getResource(node);
+            if (resource != null) {
+                resources.add(resource);
             }
         }
 
         return resources;
     }
 
-    private ResourceType getType(Node node) {
+    /**
+     * Returns a new Resource object for a given node.
+     * @param node the node representing the resource.
+     * @return a Resource object or null.
+     */
+    static Resource getResource(Node node) {
+        ResourceType type = getType(node);
+        String name = getName(node);
+
+        if (type != null && name != null) {
+            return new Resource(name, type, node);
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns the type of the Resource based on a node's attributes.
+     * @param node the node
+     * @return the ResourceType or null if it could not be inferred.
+     */
+    static ResourceType getType(Node node) {
         String nodeName = node.getLocalName();
         String typeString = null;
 
@@ -101,7 +132,12 @@
         return null;
     }
 
-    private String getName(Node node) {
+    /**
+     * Returns the name of the resource based a node's attributes.
+     * @param node the node.
+     * @return the name or null if it could not be inferred.
+     */
+    static String getName(Node node) {
         Attr attribute = (Attr) node.getAttributes().getNamedItemNS(null, ATTR_NAME);
 
         if (attribute != null) {
@@ -111,21 +147,31 @@
         return null;
     }
 
-    private Document parseDocument() throws FileNotFoundException {
+    /**
+     * Loads the DOM for a given file and returns a {@link Document} object.
+     * @param file the file to parse
+     * @return a Document object.
+     * @throws IOException
+     */
+    @NonNull
+    static Document parseDocument(File file) throws IOException {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-        BufferedInputStream stream = new BufferedInputStream(new FileInputStream(mFile));
+        BufferedInputStream stream = new BufferedInputStream(new FileInputStream(file));
         InputSource is = new InputSource(stream);
         factory.setNamespaceAware(true);
         factory.setValidating(false);
         try {
             DocumentBuilder builder = factory.newDocumentBuilder();
             return builder.parse(is);
-        } catch (Exception e) {
-            throw new BuildException(e);
+        } catch (ParserConfigurationException e) {
+            throw new IOException(e);
+        } catch (SAXException e) {
+            throw new IOException(e);
         } finally {
             try {
                 stream.close();
             } catch (IOException e) {
+                // ignore
             }
         }
     }
diff --git a/builder/src/test/java/com/android/builder/VariantConfigurationTest.java b/builder/src/test/java/com/android/builder/VariantConfigurationTest.java
index 5ee482a..47dd863 100644
--- a/builder/src/test/java/com/android/builder/VariantConfigurationTest.java
+++ b/builder/src/test/java/com/android/builder/VariantConfigurationTest.java
@@ -35,6 +35,7 @@
             mPackageName = packageName;
         }
 
+        @Override
         public String getPackage(File manifestFile) {
             return mPackageName;
         }
@@ -44,6 +45,7 @@
             return 0;
         }
 
+        @Override
         public String getVersionName(File manifestFile) {
             return "1.0";
         }
diff --git a/builder/src/test/java/com/android/builder/resources/BaseTestCase.java b/builder/src/test/java/com/android/builder/resources/BaseTestCase.java
index ac9f788..b536ca7 100644
--- a/builder/src/test/java/com/android/builder/resources/BaseTestCase.java
+++ b/builder/src/test/java/com/android/builder/resources/BaseTestCase.java
@@ -16,10 +16,12 @@
 
 package com.android.builder.resources;
 
+import com.google.common.collect.ListMultimap;
 import junit.framework.TestCase;
 
 import java.io.File;
-import java.util.Map;
+import java.io.IOException;
+import java.util.List;
 
 public abstract class BaseTestCase extends TestCase {
 
@@ -31,11 +33,48 @@
         return root;
     }
 
-    protected void verifyResources(ResourceSet resourceSet, String... resourceKeys) {
-        Map<String, Resource> map = resourceSet.getResourceMap();
+    protected static File getCanonicalRoot(String name) throws IOException {
+        File root = getRoot(name);
+        return root.getCanonicalFile();
+    }
 
-        for (String res : resourceKeys) {
-            assertNotNull("resource '" + res + "' is missing!", map.get(res));
+    protected void verifyResourceExists(ResourceMap resourceMap, String... resourceKeys) {
+        ListMultimap<String, Resource> map = resourceMap.getResourceMap();
+
+        for (String resKey : resourceKeys) {
+            List<Resource> resources = map.get(resKey);
+            assertTrue("resource '" + resKey + "' is missing!", resources.size() > 0);
+        }
+    }
+
+    /**
+     * Compares two resource maps.
+     *
+     * if <var>fullCompare</var> is <code>true</code> then it'll make sure the multimaps contains
+     * the same number of items, otherwise it'll only checks that each resource key is present
+     * in both maps.
+     *
+     * @param resourceMap1
+     * @param resourceMap2
+     * @param fullCompare
+     */
+    protected void compareResourceMaps(ResourceMap resourceMap1, ResourceMap resourceMap2,
+                                       boolean fullCompare) {
+        assertEquals(resourceMap1.size(), resourceMap2.size());
+
+        // compare the resources are all the same
+        ListMultimap<String, Resource> map1 = resourceMap1.getResourceMap();
+        ListMultimap<String, Resource> map2 = resourceMap2.getResourceMap();
+        for (String key : map1.keySet()) {
+            List<Resource> items1 = map1.get(key);
+            List<Resource> items2 = map2.get(key);
+            if (fullCompare) {
+                assertEquals("Wrong size for " + key, items1.size(), items2.size());
+            } else {
+                boolean map1HasItem = items1.size() > 0;
+                boolean map2HasItem = items2.size() > 0;
+                assertEquals("resource " + key + " missing from one map", map1HasItem, map2HasItem);
+            }
         }
     }
 }
diff --git a/builder/src/test/java/com/android/builder/resources/NoteUtilsTest.java b/builder/src/test/java/com/android/builder/resources/NoteUtilsTest.java
new file mode 100644
index 0000000..1bcd083
--- /dev/null
+++ b/builder/src/test/java/com/android/builder/resources/NoteUtilsTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2012 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.builder.resources;
+
+import junit.framework.TestCase;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+public class NoteUtilsTest extends TestCase {
+
+    public void testBasicAttributes() throws Exception {
+        Document document = createDocument();
+
+        // create two nodes
+        Node node1 = document.createElement("N1");
+        Node node2 = document.createElement("N2");
+
+        NodeUtils.addAttribute(document, node1, null, "foo", "bar");
+        NodeUtils.addAttribute(document, node2, null, "foo", "bar");
+        assertTrue(NodeUtils.compareAttributes(node1.getAttributes(), node2.getAttributes()));
+
+        NodeUtils.addAttribute(document, node1, null, "foo2", "bar2");
+        assertFalse(NodeUtils.compareAttributes(node1.getAttributes(), node2.getAttributes()));
+
+        NodeUtils.addAttribute(document, node2, null, "foo2", "bar");
+        assertFalse(NodeUtils.compareAttributes(node1.getAttributes(), node2.getAttributes()));
+    }
+
+    public void testNamespaceAttributes() throws Exception {
+        Document document = createDocument();
+
+        // create two nodes
+        Node node1 = document.createElement("N1");
+        Node node2 = document.createElement("N2");
+
+        NodeUtils.addAttribute(document, node1, "http://some.uri/", "foo", "bar");
+        NodeUtils.addAttribute(document, node2, "http://some.uri/", "foo", "bar");
+        assertTrue(NodeUtils.compareAttributes(node1.getAttributes(), node2.getAttributes()));
+
+        NodeUtils.addAttribute(document, node1, "http://some.uri/", "foo2", "bar2");
+        NodeUtils.addAttribute(document, node2, "http://some.other.uri/", "foo2", "bar2");
+        assertFalse(NodeUtils.compareAttributes(node1.getAttributes(), node2.getAttributes()));
+    }
+
+    public void testNodesWithChildrenNodes() throws Exception {
+        Document document = createDocument();
+
+        // create two nodes
+        Node node1 = document.createElement("some-node");
+        Node node2 = document.createElement("some-node");
+
+        Node child1a = document.createElement("child1");
+        Node child1b = document.createElement("child2");
+        node1.appendChild(child1a).appendChild(child1b);
+
+        Node child2a = document.createElement("child1");
+        Node child2b = document.createElement("child2");
+        node2.appendChild(child2a).appendChild(child2b);
+
+        assertTrue(NodeUtils.compareElementNode(node1, node2));
+    }
+
+    public void testAdoptNode() throws Exception {
+        Document document = createDocument();
+        Node rootNode = document.createElement("root");
+        document.appendChild(rootNode);
+
+        // create a single s
+        Node node = document.createElement("some-node");
+
+        // add some children
+        Node child1 = document.createElement("child1");
+        Node child2 = document.createElement("child2");
+        node.appendChild(child1).appendChild(child2);
+
+        // add some attributes
+        NodeUtils.addAttribute(document, node, null, "foo", "bar");
+        NodeUtils.addAttribute(document, node, "http://some.uri", "foo2", "bar2");
+        NodeUtils.addAttribute(document, child1, "http://some.other.uri", "blah", "test");
+        NodeUtils.addAttribute(document, child2, "http://another.uri", "blah", "test");
+
+        // create the other document to receive the adopted node. It must have a root node.
+        Document document2 = createDocument();
+        rootNode = document2.createElement("root");
+        document2.appendChild(rootNode);
+
+        assertTrue(NodeUtils.compareElementNode(node, NodeUtils.adoptNode(document2, node)));
+    }
+
+    private static Document createDocument() throws ParserConfigurationException {
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setNamespaceAware(true);
+        factory.setValidating(false);
+        factory.setIgnoringComments(true);
+        DocumentBuilder builder;
+
+        builder = factory.newDocumentBuilder();
+        return builder.newDocument();
+    }
+}
diff --git a/builder/src/test/java/com/android/builder/resources/ResourceMergerTest.java b/builder/src/test/java/com/android/builder/resources/ResourceMergerTest.java
index 6b856e2..c26f47d 100644
--- a/builder/src/test/java/com/android/builder/resources/ResourceMergerTest.java
+++ b/builder/src/test/java/com/android/builder/resources/ResourceMergerTest.java
@@ -16,26 +16,38 @@
 
 package com.android.builder.resources;
 
+import com.android.resources.ResourceFolderType;
+import com.android.resources.ResourceType;
+import com.google.common.base.Charsets;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Maps;
 import com.google.common.io.Files;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
 
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 public class ResourceMergerTest extends BaseTestCase {
 
-    private static ResourceSet sMergedSet = null;
+    private static ResourceMerger sResourceMerger = null;
 
     public void testMergeByCount() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
 
-        assertEquals(25, mergedSet.getSize());
+        assertEquals(25, merger.size());
     }
 
     public void testMergedResourcesByName() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
 
-        verifyResources(mergedSet,
+        verifyResourceExists(merger,
                 "drawable/icon",
                 "drawable-ldpi/icon",
                 "drawable/icon2",
@@ -64,73 +76,712 @@
     }
 
     public void testReplacedLayout() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
+        ListMultimap<String, Resource> mergedMap = merger.getResourceMap();
 
-        Resource mainLayout = mergedSet.getResourceMap().get("layout/main");
+        List<Resource> values = mergedMap.get("layout/main");
+
+        // the overlay means there's 2 versions of this resource.
+        assertEquals(2, values.size());
+        Resource mainLayout = values.get(1);
+
         ResourceFile sourceFile = mainLayout.getSource();
         assertTrue(sourceFile.getFile().getAbsolutePath().endsWith("overlay/layout/main.xml"));
     }
 
     public void testReplacedAlias() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
+        ListMultimap<String, Resource> mergedMap = merger.getResourceMap();
 
-        Resource layout = mergedSet.getResourceMap().get("layout/alias_replaced_by_file");
+
+        List<Resource> values = mergedMap.get("layout/alias_replaced_by_file");
+
+        // the overlay means there's 2 versions of this resource.
+        assertEquals(2, values.size());
+        Resource layout = values.get(1);
+
         // since it's replaced by a file, there's no node.
         assertNull(layout.getValue());
     }
 
     public void testReplacedFile() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
+        ListMultimap<String, Resource> mergedMap = merger.getResourceMap();
 
-        Resource layout = mergedSet.getResourceMap().get("layout/file_replaced_by_alias");
+        List<Resource> values = mergedMap.get("layout/file_replaced_by_alias");
+
+        // the overlay means there's 2 versions of this resource.
+        assertEquals(2, values.size());
+        Resource layout = values.get(1);
+
         // since it's replaced by a file, there's no node.
         assertNotNull(layout.getValue());
     }
 
     public void testMergeWrite() throws Exception {
-        ResourceSet mergedSet = getMergedSet();
+        ResourceMerger merger = getResourceMerger();
 
-        File folder = getWrittenSet();
+        File folder = getWrittenResources();
 
-        ResourceSet writtenSet = new ResourceSet();
+        ResourceSet writtenSet = new ResourceSet("unused");
         writtenSet.addSource(folder);
+        writtenSet.loadFromFiles();
 
-        // compare the two sets.
-        assertEquals(mergedSet.getSize(), writtenSet.getSize());
+        // compare the two maps, but not using the full map as the set loaded from the output
+        // won't contains all versions of each Resource item.
+        compareResourceMaps(merger, writtenSet, false /*full compare*/);
+    }
 
-        // compare the resources are all the same
-        Map<String, Resource> map = writtenSet.getResourceMap();
-        for (Resource item : mergedSet.getResources()) {
-            assertNotNull(map.get(item.getKey()));
+    public void testMergeBlob() throws Exception {
+        ResourceMerger merger = getResourceMerger();
+
+        File folder = Files.createTempDir();
+        merger.writeBlobTo(folder);
+
+        ResourceMerger loadedMerger = new ResourceMerger();
+        loadedMerger.loadFromBlob(folder);
+
+        compareResourceMaps(merger, loadedMerger, true /*full compare*/);
+    }
+
+    /**
+     * Tests the path replacement in the merger.xml file loaded from testData/
+     * @throws Exception
+     */
+    public void testLoadingTestPathReplacement() throws Exception {
+        File root = getRoot("baseMerge");
+        File fakeRoot = getMergedBlobFolder(root);
+
+        ResourceMerger resourceMerger = new ResourceMerger();
+        resourceMerger.loadFromBlob(fakeRoot);
+
+        List<ResourceSet> sets = resourceMerger.getResourceSets();
+        for (ResourceSet set : sets) {
+            List<File> sourceFiles = set.getSourceFiles();
+
+            // there should only be one
+            assertEquals(1, sourceFiles.size());
+
+            File sourceFile = sourceFiles.get(0);
+            assertTrue(String.format("File %s is located in %s", sourceFile, root),
+                    sourceFile.getAbsolutePath().startsWith(root.getAbsolutePath()));
         }
     }
 
-    private static ResourceSet getMergedSet() throws DuplicateResourceException {
-        if (sMergedSet == null) {
+    public void testUpdateWithBasicFiles() throws Exception {
+        File root = getIncMergeRoot("basicFiles");
+        File fakeRoot = getMergedBlobFolder(root);
+        ResourceMerger resourceMerger = new ResourceMerger();
+        resourceMerger.loadFromBlob(fakeRoot);
+
+        List<ResourceSet> sets = resourceMerger.getResourceSets();
+        assertEquals(2, sets.size());
+
+        // ----------------
+        // first set is the main one, no change here
+        ResourceSet mainSet = sets.get(0);
+        File mainBase = new File(root, "main");
+        File mainDrawable = new File(mainBase, "drawable");
+        File mainDrawableLdpi = new File(mainBase, "drawable-ldpi");
+
+        // touched/removed files:
+        File mainDrawableTouched = new File(mainDrawable, "touched.png");
+        mainSet.updateWith(mainBase, mainDrawableTouched, FileStatus.CHANGED);
+
+        File mainDrawableRemoved = new File(mainDrawable, "removed.png");
+        mainSet.updateWith(mainBase, mainDrawableRemoved, FileStatus.REMOVED);
+
+        File mainDrawableLdpiRemoved = new File(mainDrawableLdpi, "removed.png");
+        mainSet.updateWith(mainBase, mainDrawableLdpiRemoved, FileStatus.REMOVED);
+
+        // ----------------
+        // second set is the overlay one
+        ResourceSet overlaySet = sets.get(1);
+        File overlayBase = new File(root, "overlay");
+        File overlayDrawable = new File(overlayBase, "drawable");
+        File overlayDrawableHdpi = new File(overlayBase, "drawable-hdpi");
+
+        // new/removed files:
+        File overlayDrawableNewOverlay = new File(overlayDrawable, "new_overlay.png");
+        overlaySet.updateWith(overlayBase, overlayDrawableNewOverlay, FileStatus.NEW);
+
+        File overlayDrawableRemovedOverlay = new File(overlayDrawable, "removed_overlay.png");
+        overlaySet.updateWith(overlayBase, overlayDrawableRemovedOverlay, FileStatus.REMOVED);
+
+        File overlayDrawableHdpiNewAlternate = new File(overlayDrawableHdpi, "new_alternate.png");
+        overlaySet.updateWith(overlayBase, overlayDrawableHdpiNewAlternate, FileStatus.NEW);
+
+        // validate for duplicates
+        resourceMerger.validateResourceSets();
+
+        // check the content.
+        ListMultimap<String, Resource> mergedMap = resourceMerger.getResourceMap();
+
+        // check unchanged file is WRITTEN
+        List<Resource> drawableUntouched = mergedMap.get("drawable/untouched");
+        assertEquals(1, drawableUntouched.size());
+        assertTrue(drawableUntouched.get(0).isWritten());
+        assertFalse(drawableUntouched.get(0).isTouched());
+        assertFalse(drawableUntouched.get(0).isRemoved());
+
+        // check replaced file is TOUCHED
+        List<Resource> drawableTouched = mergedMap.get("drawable/touched");
+        assertEquals(1, drawableTouched.size());
+        assertTrue(drawableTouched.get(0).isWritten());
+        assertTrue(drawableTouched.get(0).isTouched());
+        assertFalse(drawableTouched.get(0).isRemoved());
+
+        // check removed file is REMOVED
+        List<Resource> drawableRemoved = mergedMap.get("drawable/removed");
+        assertEquals(1, drawableRemoved.size());
+        assertTrue(drawableRemoved.get(0).isWritten());
+        assertTrue(drawableRemoved.get(0).isRemoved());
+
+        // check new overlay: two objects, last one is TOUCHED
+        List<Resource> drawableNewOverlay = mergedMap.get("drawable/new_overlay");
+        assertEquals(2, drawableNewOverlay.size());
+        Resource newOverlay = drawableNewOverlay.get(1);
+        assertEquals(overlayDrawableNewOverlay, newOverlay.getSource().getFile());
+        assertFalse(newOverlay.isWritten());
+        assertTrue(newOverlay.isTouched());
+
+        // check new alternate: one objects, last one is TOUCHED
+        List<Resource> drawableHdpiNewAlternate = mergedMap.get("drawable-hdpi/new_alternate");
+        assertEquals(1, drawableHdpiNewAlternate.size());
+        Resource newAlternate = drawableHdpiNewAlternate.get(0);
+        assertEquals(overlayDrawableHdpiNewAlternate, newAlternate.getSource().getFile());
+        assertFalse(newAlternate.isWritten());
+        assertTrue(newAlternate.isTouched());
+
+        // write and check the result of writeResourceFolder
+        // copy the current resOut which serves as pre incremental update state.
+        File resFolder = getFolderCopy(new File(root, "resOut"));
+
+        // write the content of the resource merger.
+        resourceMerger.writeResourceFolder(resFolder);
+
+        // Check the content.
+        checkImageColor(new File(resFolder, "drawable" + File.separator + "touched.png"),
+                (int) 0xFF00FF00);
+        checkImageColor(new File(resFolder, "drawable" + File.separator + "untouched.png"),
+                (int) 0xFF00FF00);
+        checkImageColor(new File(resFolder, "drawable" + File.separator + "new_overlay.png"),
+                (int) 0xFF00FF00);
+        checkImageColor(new File(resFolder, "drawable" + File.separator + "removed_overlay.png"),
+                (int) 0xFF00FF00);
+        checkImageColor(new File(resFolder, "drawable-hdpi" + File.separator + "new_alternate.png"),
+                (int) 0xFF00FF00);
+        assertFalse(new File(resFolder, "drawable-ldpi" + File.separator + "removed.png").isFile());
+    }
+
+    public void testUpdateWithBasicValues() throws Exception {
+        File root = getIncMergeRoot("basicValues");
+        File fakeRoot = getMergedBlobFolder(root);
+        ResourceMerger resourceMerger = new ResourceMerger();
+        resourceMerger.loadFromBlob(fakeRoot);
+
+        List<ResourceSet> sets = resourceMerger.getResourceSets();
+        assertEquals(2, sets.size());
+
+        // ----------------
+        // first set is the main one, no change here
+        ResourceSet mainSet = sets.get(0);
+        File mainBase = new File(root, "main");
+        File mainValues = new File(mainBase, "values");
+        File mainValuesEn = new File(mainBase, "values-en");
+
+        // touched file:
+        File mainValuesTouched = new File(mainValues, "values.xml");
+        mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED);
+
+        // removed files
+        File mainValuesEnRemoved = new File(mainValuesEn, "values.xml");
+        mainSet.updateWith(mainBase, mainValuesEnRemoved, FileStatus.REMOVED);
+
+        // ----------------
+        // second set is the overlay one
+        ResourceSet overlaySet = sets.get(1);
+        File overlayBase = new File(root, "overlay");
+        File overlayValues = new File(overlayBase, "values");
+        File overlayValuesFr = new File(overlayBase, "values-fr");
+
+        // new files:
+        File overlayValuesNew = new File(overlayValues, "values.xml");
+        overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.NEW);
+        File overlayValuesFrNew = new File(overlayValuesFr, "values.xml");
+        overlaySet.updateWith(overlayBase, overlayValuesFrNew, FileStatus.NEW);
+
+        // validate for duplicates
+        resourceMerger.validateResourceSets();
+
+        // check the content.
+        ListMultimap<String, Resource> mergedMap = resourceMerger.getResourceMap();
+
+        // check unchanged string is WRITTEN
+        List<Resource> valuesUntouched = mergedMap.get("string/untouched");
+        assertEquals(1, valuesUntouched.size());
+        assertTrue(valuesUntouched.get(0).isWritten());
+        assertFalse(valuesUntouched.get(0).isTouched());
+        assertFalse(valuesUntouched.get(0).isRemoved());
+
+        // check replaced file is TOUCHED
+        List<Resource> valuesTouched = mergedMap.get("string/touched");
+        assertEquals(1, valuesTouched.size());
+        assertTrue(valuesTouched.get(0).isWritten());
+        assertTrue(valuesTouched.get(0).isTouched());
+        assertFalse(valuesTouched.get(0).isRemoved());
+
+        // check removed file is REMOVED
+        List<Resource> valuesRemoved = mergedMap.get("string/removed");
+        assertEquals(1, valuesRemoved.size());
+        assertTrue(valuesRemoved.get(0).isWritten());
+        assertTrue(valuesRemoved.get(0).isRemoved());
+
+        valuesRemoved = mergedMap.get("string-en/removed");
+        assertEquals(1, valuesRemoved.size());
+        assertTrue(valuesRemoved.get(0).isWritten());
+        assertTrue(valuesRemoved.get(0).isRemoved());
+
+        // check new overlay: two objects, last one is TOUCHED
+        List<Resource> valuesNewOverlay = mergedMap.get("string/new_overlay");
+        assertEquals(2, valuesNewOverlay.size());
+        Resource newOverlay = valuesNewOverlay.get(1);
+        assertFalse(newOverlay.isWritten());
+        assertTrue(newOverlay.isTouched());
+
+        // check new alternate: one objects, last one is TOUCHED
+        List<Resource> valuesFrNewAlternate = mergedMap.get("string-fr/new_alternate");
+        assertEquals(1, valuesFrNewAlternate.size());
+        Resource newAlternate = valuesFrNewAlternate.get(0);
+        assertFalse(newAlternate.isWritten());
+        assertTrue(newAlternate.isTouched());
+
+        // write and check the result of writeResourceFolder
+        // copy the current resOut which serves as pre incremental update state.
+        File resFolder = getFolderCopy(new File(root, "resOut"));
+
+        // write the content of the resource merger.
+        resourceMerger.writeResourceFolder(resFolder);
+
+        // Check the content.
+        // values/values.xml
+        Map<String, String> map = quickStringOnlyValueFileParser(
+                new File(resFolder, "values" + File.separator + "values.xml"));
+        assertEquals("untouched", map.get("untouched"));
+        assertEquals("touched", map.get("touched"));
+        assertEquals("new_overlay", map.get("new_overlay"));
+
+        // values/values-fr.xml
+        map = quickStringOnlyValueFileParser(
+                new File(resFolder, "values-fr" + File.separator + "values.xml"));
+        assertEquals("new_alternate", map.get("new_alternate"));
+
+        // deleted values-en/values.xml
+        assertFalse(new File(resFolder, "values-en" + File.separator + "values.xml").isFile());
+    }
+
+    public void testUpdateWithBasicValues2() throws Exception {
+        File root = getIncMergeRoot("basicValues2");
+        File fakeRoot = getMergedBlobFolder(root);
+        ResourceMerger resourceMerger = new ResourceMerger();
+        resourceMerger.loadFromBlob(fakeRoot);
+
+        List<ResourceSet> sets = resourceMerger.getResourceSets();
+        assertEquals(2, sets.size());
+
+        // ----------------
+        // first set is the main one, no change here
+        ResourceSet mainSet = sets.get(0);
+        File mainBase = new File(root, "main");
+        File mainValues = new File(mainBase, "values");
+
+        // ----------------
+        // second set is the overlay one
+        ResourceSet overlaySet = sets.get(1);
+        File overlayBase = new File(root, "overlay");
+        File overlayValues = new File(overlayBase, "values");
+
+        // new files:
+        File overlayValuesNew = new File(overlayValues, "values.xml");
+        overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.REMOVED);
+
+        // validate for duplicates
+        resourceMerger.validateResourceSets();
+
+        // check the content.
+        ListMultimap<String, Resource> mergedMap = resourceMerger.getResourceMap();
+
+        // check unchanged string is WRITTEN
+        List<Resource> valuesUntouched = mergedMap.get("string/untouched");
+        assertEquals(1, valuesUntouched.size());
+        assertTrue(valuesUntouched.get(0).isWritten());
+        assertFalse(valuesUntouched.get(0).isTouched());
+        assertFalse(valuesUntouched.get(0).isRemoved());
+
+        // check removed_overlay is present twice.
+        List<Resource> valuesRemovedOverlay = mergedMap.get("string/removed_overlay");
+        assertEquals(2, valuesRemovedOverlay.size());
+        // first is untouched
+        assertFalse(valuesRemovedOverlay.get(0).isWritten());
+        assertFalse(valuesRemovedOverlay.get(0).isTouched());
+        assertFalse(valuesRemovedOverlay.get(0).isRemoved());
+        // other is removed
+        assertTrue(valuesRemovedOverlay.get(1).isWritten());
+        assertFalse(valuesRemovedOverlay.get(1).isTouched());
+        assertTrue(valuesRemovedOverlay.get(1).isRemoved());
+
+        // write and check the result of writeResourceFolder
+        // copy the current resOut which serves as pre incremental update state.
+        File resFolder = getFolderCopy(new File(root, "resOut"));
+
+        // write the content of the resource merger.
+        resourceMerger.writeResourceFolder(resFolder);
+
+        // Check the content.
+        // values/values.xml
+        Map<String, String> map = quickStringOnlyValueFileParser(
+                new File(resFolder, "values" + File.separator + "values.xml"));
+        assertEquals("untouched", map.get("untouched"));
+        assertEquals("untouched", map.get("removed_overlay"));
+    }
+
+    public void testUpdateWithFilesVsValues() throws Exception {
+        File root = getIncMergeRoot("filesVsValues");
+        File fakeRoot = getMergedBlobFolder(root);
+        ResourceMerger resourceMerger = new ResourceMerger();
+        resourceMerger.loadFromBlob(fakeRoot);
+
+        List<ResourceSet> sets = resourceMerger.getResourceSets();
+        assertEquals(1, sets.size());
+
+        // ----------------
+        // Load the main set
+        ResourceSet mainSet = sets.get(0);
+        File mainBase = new File(root, "main");
+        File mainValues = new File(mainBase, ResourceFolderType.VALUES.getName());
+        File mainLayout = new File(mainBase, ResourceFolderType.LAYOUT.getName());
+
+        // touched file:
+        File mainValuesTouched = new File(mainValues, "values.xml");
+        mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED);
+
+        // new file:
+        File mainLayoutNew = new File(mainLayout, "alias_replaced_by_file.xml");
+        mainSet.updateWith(mainBase, mainLayoutNew, FileStatus.NEW);
+
+        // removed file
+        File mainLayoutRemoved = new File(mainLayout, "file_replaced_by_alias.xml");
+        mainSet.updateWith(mainBase, mainLayoutRemoved, FileStatus.REMOVED);
+
+        // validate for duplicates
+        resourceMerger.validateResourceSets();
+
+        // check the content.
+        ListMultimap<String, Resource> mergedMap = resourceMerger.getResourceMap();
+
+        // check layout/main is unchanged
+        List<Resource> layoutMain = mergedMap.get("layout/main");
+        assertEquals(1, layoutMain.size());
+        assertTrue(layoutMain.get(0).isWritten());
+        assertFalse(layoutMain.get(0).isTouched());
+        assertFalse(layoutMain.get(0).isRemoved());
+
+        // check file_replaced_by_alias has 2 version, 2nd is TOUCHED, and contains a Node
+        List<Resource> layoutReplacedByAlias = mergedMap.get("layout/file_replaced_by_alias");
+        assertEquals(2, layoutReplacedByAlias.size());
+        // 1st one is removed version, as it already existed in the item multimap
+        Resource replacedByAlias = layoutReplacedByAlias.get(0);
+        assertTrue(replacedByAlias.isWritten());
+        assertFalse(replacedByAlias.isTouched());
+        assertTrue(replacedByAlias.isRemoved());
+        assertNull(replacedByAlias.getValue());
+        assertEquals("file_replaced_by_alias.xml", replacedByAlias.getSource().getFile().getName());
+        // 2nd version is the new one
+        replacedByAlias = layoutReplacedByAlias.get(1);
+        assertFalse(replacedByAlias.isWritten());
+        assertTrue(replacedByAlias.isTouched());
+        assertFalse(replacedByAlias.isRemoved());
+        assertNotNull(replacedByAlias.getValue());
+        assertEquals("values.xml", replacedByAlias.getSource().getFile().getName());
+
+        // check alias_replaced_by_file has 2 version, 2nd is TOUCHED, and contains a Node
+        List<Resource> layoutReplacedByFile = mergedMap.get("layout/alias_replaced_by_file");
+        // 1st one is removed version, as it already existed in the item multimap
+        assertEquals(2, layoutReplacedByFile.size());
+        Resource replacedByFile = layoutReplacedByFile.get(0);
+        assertTrue(replacedByFile.isWritten());
+        assertFalse(replacedByFile.isTouched());
+        assertTrue(replacedByFile.isRemoved());
+        assertNotNull(replacedByFile.getValue());
+        assertEquals("values.xml", replacedByFile.getSource().getFile().getName());
+        // 2nd version is the new one
+        replacedByFile = layoutReplacedByFile.get(1);
+        assertFalse(replacedByFile.isWritten());
+        assertTrue(replacedByFile.isTouched());
+        assertFalse(replacedByFile.isRemoved());
+        assertNull(replacedByFile.getValue());
+        assertEquals("alias_replaced_by_file.xml", replacedByFile.getSource().getFile().getName());
+
+        // write and check the result of writeResourceFolder
+        // copy the current resOut which serves as pre incremental update state.
+        File resFolder = getFolderCopy(new File(root, "resOut"));
+
+        // write the content of the resource merger.
+        resourceMerger.writeResourceFolder(resFolder);
+
+        // deleted layout/file_replaced_by_alias.xml
+        assertFalse(new File(resFolder, "layout" + File.separator + "file_replaced_by_alias.xml")
+                .isFile());
+        // new file layout/alias_replaced_by_file.xml
+        assertTrue(new File(resFolder, "layout" + File.separator + "alias_replaced_by_file.xml")
+                .isFile());
+
+        // quick load of the values file
+        File valuesFile = new File(resFolder, "values" + File.separator + "values.xml");
+        assertTrue(valuesFile.isFile());
+        String content = Files.toString(valuesFile, Charsets.UTF_8);
+        assertTrue(content.contains("name=\"file_replaced_by_alias\""));
+        assertFalse(content.contains("name=\"alias_replaced_by_file\""));
+    }
+
+    public void testCheckValidUpdate() throws Exception {
+        // first merger
+        ResourceMerger merger1 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1", "/main/res2" },
+                new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
+        });
+
+        // 2nd merger with different order source files in sets.
+        ResourceMerger merger2 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res2", "/main/res1" },
+                new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
+        });
+
+        assertTrue(merger1.checkValidUpdate(merger2.getResourceSets()));
+
+        // write merger1 on disk to test writing empty ResourceSets.
+        File folder = Files.createTempDir();
+        merger1.writeBlobTo(folder);
+
+        // reload it
+        ResourceMerger loadedMerger = new ResourceMerger();
+        loadedMerger.loadFromBlob(folder);
+
+        assertTrue(loadedMerger.checkValidUpdate(merger1.getResourceSets()));
+    }
+
+    public void testCheckValidUpdateFail() throws Exception {
+        // Test with removed overlay
+        ResourceMerger merger1 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1", "/main/res2" },
+                new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
+        });
+
+        // 2nd merger with different order source files in sets.
+        ResourceMerger merger2 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res2", "/main/res1" },
+        });
+
+        assertFalse(merger1.checkValidUpdate(merger2.getResourceSets()));
+
+        // Test with different overlays
+        merger1 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1", "/main/res2" },
+                new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
+        });
+
+        // 2nd merger with different order source files in sets.
+        merger2 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res2", "/main/res1" },
+                new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
+        });
+
+        assertFalse(merger1.checkValidUpdate(merger2.getResourceSets()));
+
+        // Test with different overlays
+        merger1 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1", "/main/res2" },
+                new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
+                new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
+        });
+
+        // 2nd merger with different order source files in sets.
+        merger2 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res2", "/main/res1" },
+                new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
+                new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
+        });
+
+        assertFalse(merger1.checkValidUpdate(merger2.getResourceSets()));
+
+        // Test with different source files
+        merger1 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1", "/main/res2" },
+        });
+
+        // 2nd merger with different order source files in sets.
+        merger2 = createMerger(new String[][] {
+                new String[] { "main",    "/main/res1" },
+        });
+
+        assertFalse(merger1.checkValidUpdate(merger2.getResourceSets()));
+    }
+
+    private static ResourceMerger createMerger(String[][] data) {
+        ResourceMerger merger = new ResourceMerger();
+        for (String[] setData : data) {
+            ResourceSet set = new ResourceSet(setData[0]);
+            merger.addResourceSet(set);
+            for (int i = 1, n = setData.length; i < n; i++) {
+                set.addSource(new File(setData[i]));
+            }
+        }
+
+        return merger;
+    }
+
+    private static ResourceMerger getResourceMerger()
+            throws DuplicateResourceException, IOException {
+        if (sResourceMerger == null) {
             File root = getRoot("baseMerge");
 
             ResourceSet res = ResourceSetTest.getBaseResourceSet();
 
-            ResourceSet overlay = new ResourceSet();
+            ResourceSet overlay = new ResourceSet("overlay");
             overlay.addSource(new File(root, "overlay"));
+            overlay.loadFromFiles();
 
-            ResourceMerger merger = new ResourceMerger();
-            merger.addResourceSet(res);
-            merger.addResourceSet(overlay);
-
-            sMergedSet = merger.getMergedSet();
+            sResourceMerger = new ResourceMerger();
+            sResourceMerger.addResourceSet(res);
+            sResourceMerger.addResourceSet(overlay);
         }
 
-        return sMergedSet;
+        return sResourceMerger;
     }
 
-    private static File getWrittenSet() throws DuplicateResourceException, IOException {
-        ResourceSet mergedSet = getMergedSet();
+    private static File getWrittenResources() throws DuplicateResourceException, IOException {
+        ResourceMerger resourceMerger = getResourceMerger();
 
         File folder = Files.createTempDir();
 
-        mergedSet.writeTo(folder);
+        resourceMerger.writeResourceFolder(folder);
 
         return folder;
     }
+
+    /**
+     * Returns a folder containing a merger blob data for the given test data folder.
+     *
+     * This is to work around the fact that the merger blob data contains full path, but we don't
+     * know where this project is located on the drive. This rewrites the blob to contain the
+     * actual folder.
+     * (The blobs written in the test data contains placeholders for the path root and path
+     * separators)
+     *
+     * @param folder
+     * @return
+     * @throws IOException
+     */
+    private static File getMergedBlobFolder(File folder) throws IOException {
+        File originalMerger = new File(folder, ResourceMerger.FN_MERGER_XML);
+
+        String content = Files.toString(originalMerger, Charsets.UTF_8);
+
+        // search and replace $TOP$ with the root
+        content = content.replaceAll(
+                "\\$TOP\\$", folder.getAbsolutePath()).replaceAll("\\$SEP\\$", File.separator);
+
+        File tempFolder = Files.createTempDir();
+        Files.write(content, new File(tempFolder, ResourceMerger.FN_MERGER_XML), Charsets.UTF_8);
+
+        return tempFolder;
+    }
+
+    private File getIncMergeRoot(String name) throws IOException {
+        File root = getCanonicalRoot("incMergeData");
+        return new File(root, name);
+    }
+
+    private static File getFolderCopy(File folder) throws IOException {
+        File dest = Files.createTempDir();
+        copyFolder(folder, dest);
+        return dest;
+    }
+
+    private static void copyFolder(File from, File to) throws IOException {
+        if (from.isFile()) {
+            Files.copy(from, to);
+        } else if (from.isDirectory()) {
+            if (!to.exists()) {
+                to.mkdirs();
+            }
+
+            File[] children = from.listFiles();
+            if (children != null) {
+                for (File f : children) {
+                    copyFolder(f, new File(to, f.getName()));
+                }
+            }
+        }
+    }
+
+    private static void checkImageColor(File file, int expectedColor) throws IOException {
+        assertTrue("File '" + file.getAbsolutePath() + "' does not exist.", file.isFile());
+
+        BufferedImage image = ImageIO.read(file);
+        int rgb = image.getRGB(0, 0);
+        assertEquals(String.format("Expected: 0x%08X, actual: 0x%08X for file %s",
+                expectedColor, rgb, file),
+                expectedColor, rgb);
+    }
+
+    private static Map<String, String> quickStringOnlyValueFileParser(File file)
+            throws IOException {
+        Map<String, String> result = Maps.newHashMap();
+
+        Document document = ValueResourceParser.parseDocument(file);
+
+        // get the root node
+        Node rootNode = document.getDocumentElement();
+        if (rootNode == null) {
+            return Collections.emptyMap();
+        }
+
+        NodeList nodes = rootNode.getChildNodes();
+
+        for (int i = 0, n = nodes.getLength(); i < n; i++) {
+            Node node = nodes.item(i);
+
+            if (node.getNodeType() != Node.ELEMENT_NODE) {
+                continue;
+            }
+
+            ResourceType type = ValueResourceParser.getType(node);
+            if (type != ResourceType.STRING) {
+                throw new IllegalArgumentException("Only String resources supported.");
+            }
+            String name = ValueResourceParser.getName(node);
+
+            String value = null;
+
+            NodeList nodeList = node.getChildNodes();
+            nodeLoop: for (int ii = 0, nn = nodes.getLength(); ii < nn; ii++) {
+                Node subNode = nodeList.item(ii);
+
+                switch (subNode.getNodeType()) {
+                    case Node.COMMENT_NODE:
+                        break;
+                    case Node.TEXT_NODE:
+                        value = subNode.getNodeValue().trim(); // TODO: remove trim.
+                        break nodeLoop;
+                    case Node.ELEMENT_NODE:
+                        break;
+                }
+            }
+
+            result.put(name, value != null ? value : "");
+        }
+
+        return result;
+    }
 }
diff --git a/builder/src/test/java/com/android/builder/resources/ResourceSetTest.java b/builder/src/test/java/com/android/builder/resources/ResourceSetTest.java
index bcc7b88..9c0efa1 100644
--- a/builder/src/test/java/com/android/builder/resources/ResourceSetTest.java
+++ b/builder/src/test/java/com/android/builder/resources/ResourceSetTest.java
@@ -17,6 +17,7 @@
 package com.android.builder.resources;
 
 import java.io.File;
+import java.io.IOException;
 
 public class ResourceSetTest extends BaseTestCase {
 
@@ -24,13 +25,13 @@
 
     public void testBaseResourceSetByCount() throws Exception {
         ResourceSet resourceSet = getBaseResourceSet();
-        assertEquals(23, resourceSet.getSize());
+        assertEquals(23, resourceSet.size());
     }
 
     public void testBaseResourceSetByName() throws Exception {
         ResourceSet resourceSet = getBaseResourceSet();
 
-        verifyResources(resourceSet,
+        verifyResourceExists(resourceSet,
                 "drawable/icon",
                 "drawable/patch",
                 "raw/foo",
@@ -60,11 +61,12 @@
     public void testDupResourceSet() throws Exception {
         File root = getRoot("dupResourceSet");
 
-        ResourceSet set = new ResourceSet();
+        ResourceSet set = new ResourceSet("main");
         set.addSource(new File(root, "res1"));
+        set.addSource(new File(root, "res2"));
         boolean gotException = false;
         try {
-            set.addSource(new File(root, "res2"));
+            set.loadFromFiles();
         } catch (DuplicateResourceException e) {
             gotException = true;
         }
@@ -72,12 +74,13 @@
         assertTrue(gotException);
     }
 
-    static ResourceSet getBaseResourceSet() throws DuplicateResourceException {
+    static ResourceSet getBaseResourceSet() throws DuplicateResourceException, IOException {
         if (sBaseResourceSet == null) {
             File root = getRoot("baseResourceSet");
 
-            sBaseResourceSet = new ResourceSet();
+            sBaseResourceSet = new ResourceSet("main");
             sBaseResourceSet.addSource(root);
+            sBaseResourceSet.loadFromFiles();
         }
 
         return sBaseResourceSet;
diff --git a/builder/src/test/java/com/android/builder/resources/ValueResourceParserTest.java b/builder/src/test/java/com/android/builder/resources/ValueResourceParserTest.java
index dbd31a5..022b5d7 100644
--- a/builder/src/test/java/com/android/builder/resources/ValueResourceParserTest.java
+++ b/builder/src/test/java/com/android/builder/resources/ValueResourceParserTest.java
@@ -19,7 +19,7 @@
 import com.google.common.collect.Maps;
 
 import java.io.File;
-import java.io.FileNotFoundException;
+import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 
@@ -37,11 +37,9 @@
 
     public void testParsedResourcesByName() throws Exception {
         List<Resource> resources = getParsedResources();
-
-        // convert to a map
-        Map<String, Resource> map = Maps.newHashMapWithExpectedSize(resources.size());
-        for (Resource r : resources) {
-            map.put(r.getKey(), r);
+        Map<String, Resource> resourceMap = Maps.newHashMapWithExpectedSize(resources.size());
+        for (Resource item : resources) {
+            resourceMap.put(item.getKey(), item);
         }
 
         String[] resourceNames = new String[] {
@@ -65,11 +63,11 @@
         };
 
         for (String name : resourceNames) {
-            assertNotNull(name, map.get(name));
+            assertNotNull(name, resourceMap.get(name));
         }
     }
 
-    private static List<Resource> getParsedResources() throws FileNotFoundException {
+    private static List<Resource> getParsedResources() throws IOException {
         if (sResources == null) {
             File root = getRoot("baseResourceSet");
             File values = new File(root, "values");
@@ -77,6 +75,9 @@
 
             ValueResourceParser parser = new ValueResourceParser(valuesXml);
             sResources = parser.parseFile();
+
+            // create a fake resource file to allow calling Resource.getKey()
+            new ResourceFile(valuesXml, sResources, "");
         }
 
         return sResources;
diff --git a/builder/src/test/resources/testData/baseMerge/merger.xml b/builder/src/test/resources/testData/baseMerge/merger.xml
new file mode 100644
index 0000000..18613c4
--- /dev/null
+++ b/builder/src/test/resources/testData/baseMerge/merger.xml
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<merger xmlns:ns1="urn:oasis:names:tc:xliff:document:1.2">
+    <resourceSet config="main">
+        <source path="$TOP$$SEP$baseResourceSet">
+            <file name="icon" path="$TOP$$SEP$baseResourceSet$SEP$drawable$SEP$icon.png" qualifiers="" type="drawable"/>
+            <file name="patch" path="$TOP$$SEP$baseResourceSet$SEP$drawable$SEP$patch.9.png" qualifiers="" type="drawable"/>
+            <file name="file_replaced_by_alias" path="$TOP$$SEP$baseResourceSet$SEP$layout$SEP$file_replaced_by_alias.xml" qualifiers="" type="layout"/>
+            <file name="main" path="$TOP$$SEP$baseResourceSet$SEP$layout$SEP$main.xml" qualifiers="" type="layout"/>
+            <file name="foo" path="$TOP$$SEP$baseResourceSet$SEP$raw$SEP$foo.dat" qualifiers="" type="raw"/>
+            <file path="$TOP$$SEP$baseResourceSet$SEP$values$SEP$values.xml" qualifiers="">
+                <dimen name="dimen">164dp</dimen>
+                <integer name="integer">75</integer>
+                <color name="color">#00000000</color>
+                <drawable name="color_drawable">#ffffffff</drawable>
+                <declare-styleable name="declare_styleable">
+
+                    <!-- ============== -->
+                    <!-- Generic styles -->
+                    <!-- ============== -->
+                    <eat-comment/>
+
+                    <!-- Default color of foreground imagery. -->
+                    <attr format="color" name="blah"/>
+
+                    <!-- Default color of foreground imagery on an inverted background. -->
+                    <attr name="android:colorForegroundInverse"/>
+
+                </declare-styleable>
+                <style name="style">
+                    <item name="android:singleLine">true</item>
+                    <item name="android:textAppearance">@style$SEP$TextAppearance.WindowTitle</item>
+                    <item name="android:shadowColor">#BB000000</item>
+                    <item name="android:shadowRadius">2.75</item>
+                </style>
+                <string name="styled_string">Forgot your username or password\?\nVisit<b>google.com$SEP$accounts$SEP$recovery</b>.</string>
+                <attr format="dimension" name="dimen_attr"/>
+                <string-array name="string_array" translatable="false">
+                    <item/>
+                    <!-- 0 -->
+                    <item/>
+                    <!-- 1 -->
+                    <item>ABC</item>
+                    <!-- 2 -->
+                    <item>DEF</item>
+                    <!-- 3 -->
+                    <item>GHI</item>
+                    <!-- 4 -->
+                    <item>JKL</item>
+                    <!-- 5 -->
+                    <item>MNO</item>
+                    <!-- 6 -->
+                    <item>PQRS</item>
+                    <!-- 7 -->
+                    <item>TUV</item>
+                    <!-- 8 -->
+                    <item>WXYZ</item>
+                    <!-- 9 -->
+                </string-array>
+                <item name="alias_replaced_by_file" type="layout">@layout$SEP$ref </item>
+                <string name="basic_string">basic_string</string>
+                <string name="xliff_string"><ns1:g example="123" id="number">%1$s</ns1:g><ns1:g example="KB" id="unit">%2$s</ns1:g></string>
+                <attr name="enum_attr">
+                    <enum name="normal" value="0"/>
+                    <enum name="sans" value="1"/>
+                    <enum name="serif" value="2"/>
+                    <enum name="monospace" value="3"/>
+                </attr>
+                <item name="item_id" type="id"/>
+                <item name="layout_ref" type="layout">@layout$SEP$ref</item>
+                <drawable name="drawable_ref">@drawable$SEP$stat_notify_sync_anim0</drawable>
+                <attr format="string" name="string_attr"/>
+                <attr name="flag_attr">
+                    <flag name="normal" value="0"/>
+                    <flag name="bold" value="1"/>
+                    <flag name="italic" value="2"/>
+                </attr>
+            </file>
+        </source>
+    </resourceSet>
+    <resourceSet config="overlay">
+        <source path="$TOP$$SEP$baseMerge$SEP$overlay">
+            <file name="icon2" path="$TOP$$SEP$baseMerge$SEP$overlay$SEP$drawable$SEP$icon2.png" qualifiers="" type="drawable"/>
+            <file name="icon" path="$TOP$$SEP$baseMerge$SEP$overlay$SEP$drawable-ldpi$SEP$icon.png" qualifiers="ldpi" type="drawable"/>
+            <file name="alias_replaced_by_file" path="$TOP$$SEP$baseMerge$SEP$overlay$SEP$layout$SEP$alias_replaced_by_file.xml" qualifiers="" type="layout"/>
+            <file name="main" path="$TOP$$SEP$baseMerge$SEP$overlay$SEP$layout$SEP$main.xml" qualifiers="" type="layout"/>
+            <file path="$TOP$$SEP$baseMerge$SEP$overlay$SEP$values$SEP$values.xml" qualifiers="">
+                <color name="color">#FFFFFFFF</color>
+                <item name="file_replaced_by_alias" type="layout">@layout$SEP$ref</item>
+                <string name="basic_string">overlay_string</string>
+            </file>
+        </source>
+    </resourceSet>
+</merger>
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/new_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/new_overlay.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/new_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/removed_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/removed_overlay.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/removed_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/touched.png b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/touched.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/touched.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/untouched.png b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/untouched.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/main/drawable/untouched.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/merger.xml b/builder/src/test/resources/testData/incMergeData/basicFiles/merger.xml
new file mode 100644
index 0000000..6f4a3cb
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/merger.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<merger>
+    <resourceSet config="main">
+        <source path="$TOP$$SEP$main">
+            <file name="untouched" path="$TOP$$SEP$main$SEP$drawable$SEP$untouched.png" qualifiers="" type="drawable"/>
+            <file name="touched" path="$TOP$$SEP$main$SEP$drawable$SEP$touched.png" qualifiers="" type="drawable"/>
+            <file name="new_overlay" path="$TOP$$SEP$main$SEP$drawable$SEP$new_overlay.png" qualifiers="" type="drawable"/>
+            <file name="removed" path="$TOP$$SEP$main$SEP$drawable$SEP$removed.png" qualifiers="" type="drawable"/>
+            <file name="removed" path="$TOP$$SEP$main$SEP$drawable-ldpi$SEP$removed.png" qualifiers="ldpi" type="drawable"/>
+            <file name="removed_overlay" path="$TOP$$SEP$main$SEP$drawable$SEP$removed_overlay.png" qualifiers="" type="drawable"/>
+        </source>
+    </resourceSet>
+    <resourceSet config="overlay">
+        <source path="$TOP$$SEP$overlay">
+            <file name="removed_overlay" path="$TOP$$SEP$overlay$SEP$drawable$SEP$removed_overlay.png" qualifiers="" type="drawable"/>
+        </source>
+    </resourceSet>
+</merger>
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/new_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/new_overlay.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/new_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable-hdpi/new_alternate.png b/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable-hdpi/new_alternate.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable-hdpi/new_alternate.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable/new_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable/new_overlay.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/overlay/drawable/new_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable-ldpi/removed.png b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable-ldpi/removed.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable-ldpi/removed.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/new_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/new_overlay.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/new_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/removed_overlay.png b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/removed_overlay.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/removed_overlay.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/touched.png b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/touched.png
new file mode 100644
index 0000000..b55e544
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/touched.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/untouched.png b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/untouched.png
new file mode 100644
index 0000000..47e1adf
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicFiles/resOut/drawable/untouched.png
Binary files differ
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/main/values/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues/main/values/values.xml
new file mode 100644
index 0000000..32c8031
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/main/values/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="untouched">untouched</string>
+    <string name="touched">touched</string>
+    <string name="new_overlay">old_overlay</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/merger.xml b/builder/src/test/resources/testData/incMergeData/basicValues/merger.xml
new file mode 100644
index 0000000..79980b2
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/merger.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<merger>
+    <resourceSet config="main">
+        <source path="$TOP$$SEP$main">
+            <file path="$TOP$$SEP$main$SEP$values$SEP$values.xml" qualifiers="">
+                <string name="untouched">untouched</string>
+                <string name="touched">untouched</string>
+                <string name="removed">removed</string>
+                <string name="new_overlay">old_overlay</string>
+            </file>
+            <file path="$TOP$$SEP$main$SEP$values-en$SEP$values.xml" qualifiers="en">
+                <string name="removed">removed</string>
+            </file>
+        </source>
+    </resourceSet>
+    <resourceSet config="overlay">
+        <source path="$TOP$$SEP$overlay" />
+    </resourceSet>
+</merger>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values-fr/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values-fr/values.xml
new file mode 100644
index 0000000..dcfcbdd
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values-fr/values.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="new_alternate">new_alternate</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values/values.xml
new file mode 100644
index 0000000..78e296c
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/overlay/values/values.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="new_overlay">new_overlay</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values-en/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values-en/values.xml
new file mode 100644
index 0000000..b6be59a
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values-en/values.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="removed">removed</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values/values.xml
new file mode 100644
index 0000000..a3ccf6b
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues/resOut/values/values.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="untouched">untouched</string>
+    <string name="touched">untouched</string>
+    <string name="removed">removed</string>
+    <string name="new_overlay">old_overlay</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues2/main/values/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues2/main/values/values.xml
new file mode 100644
index 0000000..7a0a153
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues2/main/values/values.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="untouched">untouched</string>
+    <string name="removed_overlay">untouched</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues2/merger.xml b/builder/src/test/resources/testData/incMergeData/basicValues2/merger.xml
new file mode 100644
index 0000000..33f4356
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues2/merger.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<merger>
+    <resourceSet config="main">
+        <source path="$TOP$$SEP$main">
+            <file path="$TOP$$SEP$main$SEP$values$SEP$values.xml" qualifiers="">
+                <string name="untouched">untouched</string>
+                <string name="removed_overlay">untouched</string>
+            </file>
+        </source>
+    </resourceSet>
+    <resourceSet config="overlay">
+        <source path="$TOP$$SEP$overlay">
+            <file path="$TOP$$SEP$overlay$SEP$values$SEP$values.xml" qualifiers="">
+                <string name="removed_overlay">overlay</string>
+            </file>
+        </source>
+    </resourceSet>
+</merger>
diff --git a/builder/src/test/resources/testData/incMergeData/basicValues2/resOut/values/values.xml b/builder/src/test/resources/testData/incMergeData/basicValues2/resOut/values/values.xml
new file mode 100644
index 0000000..a0e41d1
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/basicValues2/resOut/values/values.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="untouched">untouched</string>
+    <string name="removed_overlay">overlay</string>
+</resources>
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/alias_replaced_by_file.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/alias_replaced_by_file.xml
new file mode 100644
index 0000000..b199751
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/alias_replaced_by_file.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:text="Test App - Basic"
+    android:id="@+id/text"
+    />
+</LinearLayout>
+
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/main.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/main.xml
new file mode 100644
index 0000000..b199751
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/layout/main.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:text="Test App - Basic"
+    android:id="@+id/text"
+    />
+</LinearLayout>
+
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/main/values/values.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/values/values.xml
new file mode 100644
index 0000000..028b828
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/main/values/values.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item type="layout" name="file_replaced_by_alias">@layout/main</item>
+</resources>
+
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/merger.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/merger.xml
new file mode 100644
index 0000000..c2cd240
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/merger.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<merger>
+    <resourceSet config="main">
+        <source path="$TOP$$SEP$main">
+            <file name="main" path="$TOP$$SEP$main$SEP$layout$SEP$main.xml" qualifiers="" type="layout"/>
+            <file name="file_replaced_by_alias" path="$TOP$$SEP$main$SEP$layout$SEP$file_replaced_by_alias.xml" qualifiers="" type="layout"/>
+            <file path="$TOP$$SEP$main$SEP$values$SEP$values.xml" qualifiers="">
+                <item type="layout" name="alias_replaced_by_file">@layout/main</item>
+            </file>
+        </source>
+    </resourceSet>
+</merger>
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/file_replaced_by_alias.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/file_replaced_by_alias.xml
new file mode 100644
index 0000000..b199751
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/file_replaced_by_alias.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:text="Test App - Basic"
+    android:id="@+id/text"
+    />
+</LinearLayout>
+
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/main.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/main.xml
new file mode 100644
index 0000000..b199751
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/layout/main.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:text="Test App - Basic"
+    android:id="@+id/text"
+    />
+</LinearLayout>
+
diff --git a/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/values/values.xml b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/values/values.xml
new file mode 100644
index 0000000..1fbc46e
--- /dev/null
+++ b/builder/src/test/resources/testData/incMergeData/filesVsValues/resOut/values/values.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item type="layout" name="alias_replaced_by_file">@layout/main</item>
+</resources>
+
diff --git a/gradle/src/integration-test/groovy/com/android/build/gradle/ProjectTest.groovy b/gradle/src/integration-test/groovy/com/android/build/gradle/ProjectTest.groovy
index 20d6d22..abe1848 100644
--- a/gradle/src/integration-test/groovy/com/android/build/gradle/ProjectTest.groovy
+++ b/gradle/src/integration-test/groovy/com/android/build/gradle/ProjectTest.groovy
@@ -72,7 +72,7 @@
         buildProject("flavors")
     }
 
-    void testlibsTest() {
+    void testLibsTest() {
         buildProject("libsTest")
     }
 
@@ -84,7 +84,7 @@
         buildProject("multiproject")
     }
 
-    void testMultires() {
+    void testMultiRes() {
         buildProject("multires")
     }
 
@@ -120,8 +120,8 @@
             buildProject(new File(repo, "app"), "clean", "assemble")
         } finally {
             // clean up the test repository.
-            File testrepo = new File(repo, "testrepo")
-            testrepo.deleteDir()
+            File testRepo = new File(repo, "testrepo")
+            testRepo.deleteDir()
         }
     }
 
@@ -133,6 +133,9 @@
         File[] projects = testDir.listFiles()
         for (File project : projects) {
             String name = project.name
+            if (name.startsWith(".")) {
+                continue
+            }
             if (!builtProjects.contains(name)) {
                 buildProject(name)
             }
@@ -143,7 +146,7 @@
         File project = new File(testDir, name)
         builtProjects.add(name)
 
-        buildProject(project, "clean", "assemble")
+        buildProject(project, "clean", "assembleDebug")
 
         return project;
     }
diff --git a/gradle/src/main/groovy/com/android/build/gradle/BasePlugin.groovy b/gradle/src/main/groovy/com/android/build/gradle/BasePlugin.groovy
index f964a05..5740251 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/BasePlugin.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/BasePlugin.groovy
@@ -16,56 +16,15 @@
 package com.android.build.gradle
 
 import com.android.SdkConstants
-import com.android.build.gradle.internal.AndroidDependencyImpl
-import com.android.build.gradle.internal.ApplicationVariant
-import com.android.build.gradle.internal.ConfigurationDependencies
-import com.android.build.gradle.internal.DependencyChecker
-import com.android.build.gradle.internal.LoggerWrapper
-import com.android.build.gradle.internal.ManifestDependencyImpl
-import com.android.build.gradle.internal.ProductFlavorData
-import com.android.build.gradle.internal.ProductionAppVariant
-import com.android.build.gradle.internal.SymbolFileProviderImpl
-import com.android.build.gradle.internal.TestAppVariant
-import com.android.build.gradle.internal.tasks.AidlCompileTask
-import com.android.build.gradle.internal.tasks.AndroidDependencyTask
-import com.android.build.gradle.internal.tasks.DexTask
-import com.android.build.gradle.internal.tasks.GenerateBuildConfigTask
-import com.android.build.gradle.internal.tasks.InstallTask
-import com.android.build.gradle.internal.tasks.PackageApplicationTask
-import com.android.build.gradle.internal.tasks.PrepareDependenciesTask
-import com.android.build.gradle.internal.tasks.PrepareLibraryTask
-import com.android.build.gradle.internal.tasks.MergeResourcesTask
-import com.android.build.gradle.internal.tasks.ProcessManifestTask
-import com.android.build.gradle.internal.tasks.ProcessResourcesTask
-import com.android.build.gradle.internal.tasks.ProcessTestManifestTask
-import com.android.build.gradle.internal.tasks.RunTestsTask
-import com.android.build.gradle.internal.tasks.UninstallTask
-import com.android.build.gradle.internal.tasks.ZipAlignTask
-import com.android.builder.AndroidBuilder
-import com.android.builder.AndroidDependency
-import com.android.builder.BuilderConstants
-import com.android.builder.DefaultSdkParser
-import com.android.builder.JarDependency
-import com.android.builder.ManifestDependency
-import com.android.builder.ProductFlavor
-import com.android.builder.SdkParser
-import com.android.builder.SourceProvider
-import com.android.builder.SymbolFileProvider
-import com.android.builder.VariantConfiguration
+import com.android.build.gradle.internal.*
+import com.android.build.gradle.internal.tasks.*
+import com.android.builder.*
 import com.android.utils.ILogger
 import com.google.common.collect.ArrayListMultimap
 import com.google.common.collect.Lists
 import com.google.common.collect.Multimap
-import org.gradle.api.DefaultTask
-import org.gradle.api.GradleException
-import org.gradle.api.NamedDomainObjectContainer
-import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ModuleVersionIdentifier
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.artifacts.ResolvedArtifact
-import org.gradle.api.artifacts.SelfResolvingDependency
+import org.gradle.api.*
+import org.gradle.api.artifacts.*
 import org.gradle.api.artifacts.result.ResolvedDependencyResult
 import org.gradle.api.artifacts.result.ResolvedModuleVersionResult
 import org.gradle.api.internal.plugins.ProcessResources
@@ -326,10 +285,11 @@
 
         mergeResourcesTask.plugin = this
         mergeResourcesTask.variant = variant
+        mergeResourcesTask.incrementalFolder = project.file("$project.buildDir/incremental/$variant.dirName")
 
         mergeResourcesTask.conventionMapping.inputResourceSets = { variant.config.resourceSets }
         mergeResourcesTask.conventionMapping.rawInputFolders = {
-            MergeResourcesTask.inlineInputs(variant.config.resourceSets)
+            BaseTask.flattenSourceSets(variant.config.resourceSets)
         }
 
         mergeResourcesTask.conventionMapping.outputDir = {
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/AaptOptionsImpl.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/AaptOptionsImpl.groovy
index 55773e0..1b65438 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/AaptOptionsImpl.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/AaptOptionsImpl.groovy
@@ -29,7 +29,7 @@
     private List<String> noCompressList
 
     public void setIgnoreAssetsPattern(String ignoreAssetsPattern) {
-        ignoreAssetsPattern = ignoreAssetsPattern
+        this.ignoreAssetsPattern = ignoreAssetsPattern
     }
 
     @Override
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/DefaultAndroidSourceSet.java b/gradle/src/main/groovy/com/android/build/gradle/internal/DefaultAndroidSourceSet.java
index 6d52086..77a6760 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/DefaultAndroidSourceSet.java
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/DefaultAndroidSourceSet.java
@@ -65,6 +65,7 @@
         String javaResourcesDisplayName = String.format("%s Java resources", displayName);
         javaResources = new DefaultSourceDirectorySet(javaResourcesDisplayName, fileResolver);
         javaResources.getFilter().exclude(new Spec<FileTreeElement>() {
+            @Override
             public boolean isSatisfiedBy(FileTreeElement element) {
                 return javaSource.contains(element.getFile());
             }
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/AidlCompileTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/AidlCompileTask.groovy
index f65f9ba..f34db20 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/AidlCompileTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/AidlCompileTask.groovy
@@ -15,11 +15,8 @@
  */
 
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.AidlCompile
 import org.gradle.api.tasks.InputFiles
-import org.gradle.api.tasks.TaskAction
-
 /**
  */
 public class AidlCompileTask extends AidlCompile {
@@ -30,8 +27,8 @@
     @InputFiles
     List<File> importDirs
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().compileAidl(getSourceDirs(), getSourceOutputDir(), getImportDirs())
     }
 }
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/BaseTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/BaseTask.groovy
index 13df81e..d6146c4 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/BaseTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/BaseTask.groovy
@@ -18,14 +18,136 @@
 import com.android.build.gradle.BasePlugin
 import com.android.build.gradle.internal.ApplicationVariant
 import com.android.builder.AndroidBuilder
+import com.android.builder.internal.incremental.ChangeManager
+import com.android.builder.resources.FileStatus
+import com.android.builder.resources.SourceSet
+import com.google.common.collect.Lists
 import org.gradle.api.DefaultTask
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskInputs
 
 public abstract class BaseTask extends DefaultTask {
 
     BasePlugin plugin
     ApplicationVariant variant
 
+    @OutputDirectory @Optional
+    File incrementalFolder
+
+    private Map<File, FileStatus> sEmptyMap = Collections.emptyMap()
+
     protected AndroidBuilder getBuilder() {
-        return plugin.getAndroidBuilder(variant);
+        return plugin.getAndroidBuilder(variant)
+    }
+
+    /**
+     * Whether this task can support incremental update using the {@link ChangeManager}
+     *
+     * @return whether this task can support incremental update.
+     */
+    protected boolean isIncremental() {
+        return false
+    }
+
+    /**
+     * Actual task action. This is called when a full run is needed, which is always the case if
+     * {@link #isIncremental()} returns false.
+     *
+     */
+    protected abstract void doFullTaskAction();
+
+    /**
+     * Optional incremental task action.
+     * Only used if {@link #isIncremental()} returns true.
+     *
+     * @param changedInputs the changed input files.
+     * @param changedOutputs the changed output files.
+     */
+    protected void doIncrementalTaskAction(Map<File, FileStatus> changedInputs,
+                                           Map<File, FileStatus> changedOutputs) {
+        // do nothing.
+    }
+
+    protected Collection<File> getOutputForIncrementalBuild() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Actual entry point for the action.
+     * Calls out to the doTaskAction as needed.
+     */
+    @TaskAction
+    void taskAction() {
+        if (!isIncremental() || incrementalFolder == null) {
+            doFullTaskAction()
+            return;
+        }
+
+        // load known state.
+        ChangeManager changeManager = new ChangeManager()
+        boolean fullBuild = !changeManager.load(incrementalFolder)
+
+        // update with current files.
+        TaskInputs inputs = getInputs()
+        FileCollection inputCollection = inputs.getFiles()
+
+        for (File f : inputCollection.files) {
+            changeManager.addInput(f)
+        }
+
+        for (File f : getOutputForIncrementalBuild()) {
+            changeManager.addOutput(f);
+        }
+
+        try {
+            // force full build if output changed somehow.
+            Map<File, FileStatus> changedOutputs = changeManager.getChangedOutputs()
+            Map<File, FileStatus> changedInputs = changeManager.getChangedInputs()
+            if (fullBuild) {
+                project.logger.info("No incremental data: full task run")
+                doFullTaskAction();
+            } else if (!changedOutputs.isEmpty()) {
+                for (File f : changedOutputs.keySet()) {
+                    project.logger.info(">> " + f)
+                }
+                project.logger.info("Changed output: full task run")
+
+                doFullTaskAction();
+            } else if (changedInputs.isEmpty() && changedOutputs.isEmpty()) {
+                // both input and output are empty, this is something we don't control
+                // through files, just do a full run
+                project.logger.info("Changed non file input/output: full task run")
+                doFullTaskAction()
+            } else {
+                doIncrementalTaskAction(
+                        changeManager.getChangedInputs(), changeManager.getChangedOutputs())
+            }
+
+            // update the outputs post task-action, to record their state
+            // for the next run
+            changeManager.updateOutputs(getOutputForIncrementalBuild())
+
+            // write the result down to be used next time the task is run.
+            changeManager.write(incrementalFolder)
+        } catch (Exception e) {
+            // Easiest to do here, is to delete the incremental Data so that
+            // next run is full.
+            ChangeManager.delete(incrementalFolder)
+
+            throw e
+        }
+    }
+
+    public static List<File> flattenSourceSets(List<? extends SourceSet> resourceSets) {
+        List<File> list = Lists.newArrayList();
+
+        for (SourceSet sourceSet : resourceSets) {
+            list.addAll(sourceSet.sourceFiles)
+        }
+
+        return list;
     }
 }
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/DexTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/DexTask.groovy
index f62979a..a46e890 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/DexTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/DexTask.groovy
@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.Dex
 import com.android.builder.DexOptions
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Nested
-import org.gradle.api.tasks.TaskAction
 
 public class DexTask extends Dex {
 
@@ -32,8 +30,8 @@
     @Nested
     DexOptions dexOptions
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().convertByteCode(
                 getSourceFiles(),
                 getLibraries(),
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/GenerateBuildConfigTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/GenerateBuildConfigTask.groovy
index e7bf2e6..df8b9f9 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/GenerateBuildConfigTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/GenerateBuildConfigTask.groovy
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.GenerateBuildConfig
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
 
 public class GenerateBuildConfigTask extends GenerateBuildConfig {
 
@@ -30,8 +28,8 @@
     @Input
     List<String> javaLines;
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().generateBuildConfig(
                 getPackageName(),
                 isDebuggable(),
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/MergeResourcesTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/MergeResourcesTask.groovy
index c51cb77..ac43974 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/MergeResourcesTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/MergeResourcesTask.groovy
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
  *
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.MergeResources
-import com.google.common.collect.Lists
+import com.android.builder.resources.FileStatus
+import com.android.builder.resources.ResourceMerger
+import com.android.builder.resources.ResourceSet
+import com.android.utils.Pair
 import org.gradle.api.tasks.InputFiles
-import org.gradle.api.tasks.TaskAction
 
 class MergeResourcesTask extends MergeResources {
 
@@ -27,29 +28,92 @@
     Iterable<File> rawInputFolders
 
     // actual inputs
-    List<List<File>> inputResourceSets
+    List<ResourceSet> inputResourceSets
 
-    @TaskAction
-    void generate() {
-        // this is not yet incremental. Need to clean up the previous merge result.
-        File destinationDir = getOutputDir()
-
-        deleteFolder(destinationDir)
-        destinationDir.mkdir()
-
-        getBuilder().mergeResources(destinationDir.absolutePath, getInputResourceSets())
+    @Override
+    protected boolean isIncremental() {
+        return true
     }
 
-    static Iterable<File> inlineInputs(List<List<File>> inputs) {
-        List<File> list = Lists.newArrayList();
+    @Override
+    protected Collection<File> getOutputForIncrementalBuild() {
+        return Collections.singletonList(getOutputDir())
+    }
 
-        for (List<File> folders : inputs) {
-            for (File folder : folders) {
-                list.add(folder);
+    @Override
+    protected void doFullTaskAction() {
+        // this is full run, clean the previous output
+        File destinationDir = getOutputDir()
+        deleteFolder(destinationDir)
+        destinationDir.mkdirs()
+
+        List<ResourceSet> resourceSets = getInputResourceSets()
+
+        // create a new merger and populate it with the sets.
+        ResourceMerger merger = new ResourceMerger()
+
+        for (ResourceSet resourceSet : resourceSets) {
+            // set needs to be loaded.
+            resourceSet.loadFromFiles()
+            merger.addResourceSet(resourceSet)
+        }
+
+        // get the merged set and write it down.
+        merger.writeResourceFolder(destinationDir)
+
+        // No exception? Write the known state.
+        merger.writeBlobTo(getIncrementalFolder())
+    }
+
+    @Override
+    protected void doIncrementalTaskAction(Map<File, FileStatus> changedInputs,
+                                           Map<File, FileStatus> changedOutputs) {
+        // create a merger and load the known state.
+        ResourceMerger merger = new ResourceMerger()
+        if (!merger.loadFromBlob(getIncrementalFolder())) {
+            doFullTaskAction()
+            return
+        }
+
+        // compare the known state to the current sets to detect incompatibility.
+        // This is in case there's a change that's too hard to do incrementally. In this case
+        // we'll simply revert to full build.
+        List<ResourceSet> resourceSets = getInputResourceSets()
+
+        if (!merger.checkValidUpdate(resourceSets)) {
+            project.logger.info("Changed Resource sets: full task run!")
+            doFullTaskAction()
+            return
+        }
+
+        // The incremental process is the following:
+        // Loop on all the changed files, find which ResourceSet it belongs to, then ask
+        // the resource set to update itself with the new file.
+        for (Map.Entry<File, FileStatus> entry : changedInputs.entrySet()) {
+            File changedFile = entry.getKey()
+
+            Pair<ResourceSet, File> matchSet = merger.getResourceSetContaining(changedFile)
+            assert matchSet != null
+            if (matchSet == null) {
+                doFullTaskAction()
+                return
+            }
+
+            // do something?
+            if (!matchSet.getFirst().updateWith(
+                    matchSet.getSecond(), changedFile, entry.getValue())) {
+                project.logger.info(
+                        String.format("Failed to process %s event! Full task run",
+                                entry.getValue()))
+                doFullTaskAction()
+                return
             }
         }
 
-        return list;
+        merger.writeResourceFolder(getOutputDir())
+
+        // No exception? Write the known state.
+        merger.writeBlobTo(getIncrementalFolder())
     }
 
     private static void deleteFolder(File folder) {
@@ -59,7 +123,7 @@
                 if (file.isDirectory()) {
                     deleteFolder(file)
                 }
-                file.delete();
+                file.delete()
             }
         }
 
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PackageApplicationTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PackageApplicationTask.groovy
index 101f111..e1de634 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PackageApplicationTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PackageApplicationTask.groovy
@@ -14,13 +14,11 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.PackageApplication
 import com.android.builder.packaging.DuplicateFileException
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Optional
-import org.gradle.api.tasks.TaskAction
 
 public class PackageApplicationTask extends PackageApplication {
 
@@ -45,9 +43,8 @@
     @Input @Optional
     String signingKeyPassword
 
-    @TaskAction
-    void generate() {
-
+    @Override
+    protected void doFullTaskAction() {
         try {
             getBuilder().packageApk(
                     getResourceFile().absolutePath,
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PrepareDependenciesTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PrepareDependenciesTask.groovy
index 77f5182..7d0f7e4 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PrepareDependenciesTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/PrepareDependenciesTask.groovy
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.internal.DependencyChecker
 import com.android.utils.Pair
-import org.gradle.api.tasks.TaskAction
 
 public class PrepareDependenciesTask extends BaseTask {
     final List<DependencyChecker> checkers = []
@@ -27,8 +25,8 @@
         androidDependencies.add(api)
     }
 
-    @TaskAction
-    def prepare() {
+    @Override
+    protected void doFullTaskAction() {
         def minSdkVersion = variant.config.minSdkVersion
 
         for (DependencyChecker checker : checkers) {
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessManifestTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessManifestTask.groovy
index c829a18..3543bd9 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessManifestTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessManifestTask.groovy
@@ -22,7 +22,6 @@
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Nested
 import org.gradle.api.tasks.Optional
-import org.gradle.api.tasks.TaskAction
 
 /**
  */
@@ -49,8 +48,8 @@
     @Input
     int targetSdkVersion
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().processManifest(
                 getMainManifest(),
                 getManifestOverlays(),
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessResourcesTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessResourcesTask.groovy
index af53b65..993562c 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessResourcesTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessResourcesTask.groovy
@@ -18,11 +18,11 @@
 import com.android.build.gradle.tasks.ProcessResources
 import com.android.builder.SymbolFileProvider
 import com.android.builder.VariantConfiguration
+import com.android.builder.resources.FileStatus
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.Nested
 import org.gradle.api.tasks.Optional
-import org.gradle.api.tasks.TaskAction
 
 public class ProcessResourcesTask extends ProcessResources {
 
@@ -44,9 +44,8 @@
     @Nested
     AaptOptionsImpl aaptOptions
 
-    @TaskAction
-    void generate() {
-
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().processResources(
                 getManifestFile(),
                 getMergedResFolder(),
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessTestManifestTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessTestManifestTask.groovy
index 1edbe21..f140ec6 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessTestManifestTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ProcessTestManifestTask.groovy
@@ -14,13 +14,10 @@
  * limitations under the License.
  */
 package com.android.build.gradle.internal.tasks
-
 import com.android.build.gradle.tasks.ProcessManifest
 import com.android.builder.ManifestDependency
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Nested
-import org.gradle.api.tasks.TaskAction
-
 /**
  */
 class ProcessTestManifestTask extends ProcessManifest {
@@ -40,8 +37,8 @@
     @Nested
     List<ManifestDependency> libraries
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         getBuilder().processTestManifest(
                 getTestPackageName(),
                 getMinSdkVersion(),
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/RunTestsTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/RunTestsTask.groovy
index e7f605a..ec0873c 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/RunTestsTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/RunTestsTask.groovy
@@ -16,8 +16,6 @@
 package com.android.build.gradle.internal.tasks
 
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
-
 /**
  * Run tests for a given variant
  */
@@ -26,8 +24,8 @@
     @Input
     File sdkDir
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         List<String> command = variant.runCommand
 
         logger.info("Running tests with command: " + command)
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/UninstallTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/UninstallTask.groovy
index 42bb30a..995eda0 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/UninstallTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/UninstallTask.groovy
@@ -15,15 +15,15 @@
  */
 package com.android.build.gradle.internal.tasks
 
+import com.android.builder.resources.FileStatus
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
 
 public class UninstallTask extends BaseTask {
     @Input
     File sdkDir
 
-    @TaskAction
-    void generate() {
+    @Override
+    protected void doFullTaskAction() {
         String packageName = variant.package
         logger.info("Uninstalling app: " + packageName)
         project.exec {
diff --git a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ZipAlignTask.groovy b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ZipAlignTask.groovy
index e69ce14..37884cb 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ZipAlignTask.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/internal/tasks/ZipAlignTask.groovy
@@ -25,7 +25,7 @@
     File sdkDir
 
     @TaskAction
-    void generate() {
+    void zipAlign() {
         project.exec {
             executable = new File(getSdkDir(), "tools${File.separator}zipalign")
             args '-f', '4'
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/AidlCompile.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/AidlCompile.groovy
index 50f938b..8e597d2 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/AidlCompile.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/AidlCompile.groovy
@@ -21,7 +21,7 @@
 
 /**
  */
-public class AidlCompile extends BaseTask {
+public abstract class AidlCompile extends BaseTask {
 
     @OutputDirectory
     File sourceOutputDir
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/Dex.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/Dex.groovy
index f5a6540..c1b1daf 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/Dex.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/Dex.groovy
@@ -18,7 +18,7 @@
 import com.android.build.gradle.internal.tasks.BaseTask
 import org.gradle.api.tasks.OutputFile
 
-public class Dex extends BaseTask {
+public abstract class Dex extends BaseTask {
 
     @OutputFile
     File outputFile
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/GenerateBuildConfig.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/GenerateBuildConfig.groovy
index 7f30c8b..9c75214 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/GenerateBuildConfig.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/GenerateBuildConfig.groovy
@@ -18,7 +18,7 @@
 import com.android.build.gradle.internal.tasks.BaseTask
 import org.gradle.api.tasks.OutputDirectory
 
-public class GenerateBuildConfig extends BaseTask {
+public abstract class GenerateBuildConfig extends BaseTask {
 
     @OutputDirectory
     File sourceOutputDir
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/MergeResources.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/MergeResources.groovy
index 0ed64ea..c824d3d 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/MergeResources.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/MergeResources.groovy
@@ -18,7 +18,7 @@
 import com.android.build.gradle.internal.tasks.BaseTask
 import org.gradle.api.tasks.OutputDirectory
 
-class MergeResources extends BaseTask {
+abstract class MergeResources extends BaseTask {
 
     @OutputDirectory
     File outputDir
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/PackageApplication.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/PackageApplication.groovy
index 1ebe367..07ee2db 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/PackageApplication.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/PackageApplication.groovy
@@ -21,7 +21,7 @@
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputFile
 
-public class PackageApplication extends BaseTask {
+public abstract class PackageApplication extends BaseTask {
     @InputFile
     File resourceFile
 
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/ProcessResources.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/ProcessResources.groovy
index da4ab76..c2355aa 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/ProcessResources.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/ProcessResources.groovy
@@ -22,7 +22,7 @@
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.OutputFile
 
-public class ProcessResources extends BaseTask {
+public abstract class ProcessResources extends BaseTask {
 
     @InputFile
     File manifestFile
diff --git a/gradle/src/main/groovy/com/android/build/gradle/tasks/ZipAlign.groovy b/gradle/src/main/groovy/com/android/build/gradle/tasks/ZipAlign.groovy
index d41a981..a71d65d 100644
--- a/gradle/src/main/groovy/com/android/build/gradle/tasks/ZipAlign.groovy
+++ b/gradle/src/main/groovy/com/android/build/gradle/tasks/ZipAlign.groovy
@@ -19,7 +19,7 @@
 import org.gradle.api.tasks.InputFile
 import org.gradle.api.tasks.OutputFile
 
-public class ZipAlign extends DefaultTask {
+public abstract class ZipAlign extends DefaultTask {
     @OutputFile
     File outputFile