diff --git a/tests/tests/graphics/jni/Android.mk b/tests/tests/graphics/jni/Android.mk
index 629ae64..ff7d081 100644
--- a/tests/tests/graphics/jni/Android.mk
+++ b/tests/tests/graphics/jni/Android.mk
@@ -24,12 +24,13 @@
 	CtsGraphicsJniOnLoad.cpp \
 	android_graphics_cts_ANativeWindowTest.cpp \
 	android_graphics_cts_BitmapTest.cpp \
+	android_graphics_cts_SyncTest.cpp \
 	android_graphics_cts_VulkanFeaturesTest.cpp
 
-LOCAL_CFLAGS += -Wall -Werror
+LOCAL_CFLAGS += -std=c++14 -Wall -Werror
 
 LOCAL_STATIC_LIBRARIES := libvkjson_ndk
-LOCAL_SHARED_LIBRARIES := libandroid libvulkan libnativewindow liblog libdl libjnigraphics
+LOCAL_SHARED_LIBRARIES := libandroid libvulkan libnativewindow libsync liblog libdl libjnigraphics
 LOCAL_NDK_STL_VARIANT := c++_static
 
 LOCAL_SDK_VERSION := current
diff --git a/tests/tests/graphics/jni/android_graphics_cts_SyncTest.cpp b/tests/tests/graphics/jni/android_graphics_cts_SyncTest.cpp
new file mode 100644
index 0000000..aeea02c
--- /dev/null
+++ b/tests/tests/graphics/jni/android_graphics_cts_SyncTest.cpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2017 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.
+ *
+ */
+
+#define LOG_TAG "SyncTest"
+
+#include <poll.h>
+#include <unistd.h>
+
+#include <array>
+#include <memory>
+
+#include <jni.h>
+
+#include <android/sync.h>
+
+namespace {
+
+enum {
+    STATUS_ERROR = -1,
+    STATUS_UNSIGNALED = 0,
+    STATUS_SIGNALED = 1,
+};
+
+jboolean syncPoll(JNIEnv* env, jclass /*clazz*/, jintArray fds_array, jintArray status_array) {
+    jsize n = env->GetArrayLength(fds_array);
+    if (env->GetArrayLength(status_array) != n)
+        return JNI_FALSE;
+    std::unique_ptr<pollfd[]> pollfds = std::make_unique<pollfd[]>(n);
+
+    jint* fds = static_cast<jint*>(env->GetPrimitiveArrayCritical(fds_array, nullptr));
+    for (jsize i = 0; i < n; i++) {
+        pollfds[i].fd = fds[i];
+        pollfds[i].events = POLLIN;
+    }
+    env->ReleasePrimitiveArrayCritical(fds_array, fds, 0);
+
+    int ret;
+    do {
+        ret = poll(pollfds.get(), n, -1 /* infinite timeout */);
+    } while (ret == -1 && errno == EINTR);
+    if (ret == -1)
+        return JNI_FALSE;
+
+    jint* status = static_cast<jint*>(env->GetPrimitiveArrayCritical(status_array, nullptr));
+    for (jsize i = 0; i < n; i++) {
+        if (pollfds[i].fd < 0)
+            continue;
+        if ((pollfds[i].revents & (POLLERR | POLLNVAL)) != 0)
+            status[i] = STATUS_ERROR;
+        else if ((pollfds[i].revents & POLLIN) != 0)
+            status[i] = STATUS_SIGNALED;
+        else
+            status[i] = STATUS_UNSIGNALED;
+    }
+    env->ReleasePrimitiveArrayCritical(status_array, status, 0);
+
+    return JNI_TRUE;
+}
+
+jint syncMerge(JNIEnv* env, jclass /*clazz*/, jstring nameStr, jint fd1, jint fd2) {
+    const char* name = env->GetStringUTFChars(nameStr, nullptr);
+    int32_t result_fd = sync_merge(name, fd1, fd2);
+    env->ReleaseStringUTFChars(nameStr, name);
+    return result_fd;
+}
+
+jobject syncFileInfo(JNIEnv* /*env*/, jclass /*clazz*/, jint fd) {
+    auto info = sync_file_info(fd);
+    if (!info) return nullptr;
+    // TODO: convert to SyncFileInfo
+    sync_file_info_free(info);
+    return nullptr;
+}
+
+void syncClose(int fd) {
+    close(fd);
+}
+
+const std::array<JNINativeMethod, 4> JNI_METHODS = {{
+    { "nSyncPoll", "([I[I)Z", (void*)syncPoll },
+    { "nSyncMerge", "(Ljava/lang/String;II)I", (void*)syncMerge },
+    { "nSyncFileInfo", "(I)Landroid/graphics/cts/SyncTest/SyncFileInfo;", (void*)syncFileInfo },
+    { "nSyncClose", "(I)V", (void*)syncClose },
+}};
+
+}
+
+int register_android_graphics_cts_SyncTest(JNIEnv* env) {
+    jclass clazz = env->FindClass("android/graphics/cts/SyncTest");
+    return env->RegisterNatives(clazz, JNI_METHODS.data(), JNI_METHODS.size());
+}
diff --git a/tests/tests/graphics/src/android/graphics/cts/SyncTest.java b/tests/tests/graphics/src/android/graphics/cts/SyncTest.java
new file mode 100644
index 0000000..a82adfc
--- /dev/null
+++ b/tests/tests/graphics/src/android/graphics/cts/SyncTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2017 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 android.graphics.cts;
+
+import static org.junit.Assert.assertEquals;
+import static android.opengl.EGL14.*;
+
+import android.opengl.EGL14;
+import android.opengl.EGLConfig;
+import android.opengl.EGLContext;
+import android.opengl.EGLDisplay;
+import android.opengl.EGLSurface;
+import android.opengl.GLES20;
+import android.support.test.filters.SmallTest;
+
+import java.util.concurrent.CyclicBarrier;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+
+// This class contains tests for the Linux kernel sync file system, and the NDK interfaces for it
+// (android/sync.h). Unfortunately, the interfaces exposed by the kernel make it difficult to test
+// for a couple reasons:
+//
+// (a) There isn't a standard kernel interface for creating a fence/sync_file. Drivers can create
+//     them via driver-specific interfaces. Currently this means we have to use APIs like OpenGL ES
+//     or interact with the system compositor in order to generate fences. That makes tests larger
+//     and more complicated than they otherwise need to be.
+//
+//     This is further complicated by the fact that most of the time GPU work executes in the order
+//     it was submitted to the kernel; there isn't much out-of-order execution in practice. So
+//     detecting some kinds of bugs is difficult using only the GPU as an event source.
+//
+// (b) A core principal of sync files is that they cannot be created until the work that will
+//     signal them has been submitted to the kernel, and will complete without further action from
+//     userland. This means that it is impossible to reliably do something before a sync file has
+//     signaled.
+
+@SmallTest
+@RunWith(BlockJUnit4ClassRunner.class)
+public class SyncTest {
+
+    static {
+        System.loadLibrary("ctsgraphics_jni");
+    }
+
+    private static final String TAG = SyncTest.class.getSimpleName();
+    private static final boolean DEBUG = false;
+
+    private EGLDisplay mEglDisplay = EGL_NO_DISPLAY;
+    private EGLConfig mEglConfig = null;
+
+    @Before
+    public void setup() throws Throwable {
+        mEglDisplay = EGL14.eglGetDisplay(EGL_DEFAULT_DISPLAY);
+        if (mEglDisplay == EGL_NO_DISPLAY) {
+            throw new RuntimeException("no EGL display");
+        }
+        int[] major = new int[1];
+        int[] minor = new int[1];
+        if (!EGL14.eglInitialize(mEglDisplay, major, 0, minor, 0)) {
+            throw new RuntimeException("error in eglInitialize");
+        }
+
+        int[] numConfigs = new int[1];
+        EGLConfig[] configs = new EGLConfig[1];
+        if (!EGL14.eglChooseConfig(mEglDisplay,
+                new int[] {
+                    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+                    EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+                    EGL_BUFFER_SIZE, 32,
+                    EGL_NONE},
+                0, configs, 0, 1, numConfigs, 0)) {
+            throw new RuntimeException("eglChooseConfig failed");
+        }
+        mEglConfig = configs[0];
+    }
+
+    @After
+    public void teardown() throws Throwable {
+        EGL14.eglTerminate(mEglDisplay);
+    }
+
+    @Test
+    public void testMergedSyncSignalOrder() {
+        // TODO
+    }
+
+    private static final int STATUS_UNSIGNALED = 0;
+    private static final int STATUS_SIGNALED = 1;
+    private static final int STATUS_ERROR = -1;
+    private static class SyncFileInfo {
+        String name;            // char name[32]
+        int status;             // __s32 status
+        long flags;             // __u32 flags
+        SyncFenceInfo[] fences; // __u32 num_fences; __u64 sync_fence_info
+    }
+    private static class SyncFenceInfo {
+        String name;            // char obj_name[32]
+        String driver_name;     // char driver_name[32]
+        int status;             // __s32 status
+        long flags;             // __u32 flags
+        long timestamp_ns;      // __u64 timestamp_ns
+    }
+
+    private static native boolean nSyncPoll(int[] fds, int[] status);
+    private static native int nSyncMerge(String name, int fd1, int fd2);
+    private static native SyncFileInfo nSyncFileInfo(int fd);
+    private static native void nSyncClose(int fd);
+}