diff --git a/src/test/java/com/intel/jndn/utils/TestHelper.java b/src/test/java/com/intel/jndn/utils/TestHelper.java
index fbf931e..a73aba4 100644
--- a/src/test/java/com/intel/jndn/utils/TestHelper.java
+++ b/src/test/java/com/intel/jndn/utils/TestHelper.java
@@ -24,6 +24,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import net.named_data.jndn.Data;
 import net.named_data.jndn.Face;
 import net.named_data.jndn.Name;
@@ -49,19 +51,15 @@
   }
 
   public static List<CompletableFuture<Data>> buildFutureSegments(Name name, int from, int to) {
-    List<CompletableFuture<Data>> list = new ArrayList<>();
-    for (Data d : buildSegments(name, from, to)) {
-      list.add(CompletableFuture.completedFuture(d));
-    }
-    return list;
+    return buildSegments(name, from, to).stream()
+            .map((d) -> CompletableFuture.completedFuture(d))
+            .collect(Collectors.toList());
   }
 
   public static List<Data> buildSegments(Name name, int from, int to) {
-    List<Data> list = new ArrayList<>();
-    for (Integer i = from; i < to; i++) {
-      list.add(buildData(new Name(name).appendSegment(i), i.toString(), to - 1));
-    }
-    return list;
+    return IntStream.range(from, to).boxed()
+            .map((i) -> buildData(new Name(name).appendSegment(i), i.toString(), to - 1))
+            .collect(Collectors.toList());
   }
 
   public static Data buildData(Name name, String content) {
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientFileTestIT.java b/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientFileTestIT.java
new file mode 100644
index 0000000..45572a7
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientFileTestIT.java
@@ -0,0 +1,118 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 3, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+package com.intel.jndn.utils.client.impl;
+
+import com.intel.jndn.utils.Client;
+import com.intel.jndn.utils.TestHelper;
+import com.intel.jndn.utils.server.impl.SegmentedServerHelper;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import net.named_data.jndn.Data;
+import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.InterestFilter;
+import net.named_data.jndn.Name;
+import net.named_data.jndn.OnInterestCallback;
+import net.named_data.jndn.security.SecurityException;
+import org.junit.Test;
+
+/**
+ * Test AdvancedClient.java; requires a hostname to an NFD accepting a generated
+ * key to register prefixes, e.g. mvn test -Dnfd.ip=10.10.10.1
+ *
+ * @author Andrew Brown <andrew.brown@intel.com>
+ */
+public class AdvancedClientFileTestIT {
+
+  private static final Logger logger = Logger.getLogger(AdvancedClientFileTestIT.class.getName());
+  private static final Name PREFIX = new Name("/test/advanced-client").append(TestHelper.buildRandomString(10));
+  private static final int NUM_MESSAGES = 100;
+  private static final int MESSAGE_SIZE_BYTES = 10000;
+  private static final int SEGMENT_SIZE_BYTES = 5000;
+  private final TestHelper.NdnEnvironment environment;
+
+  public AdvancedClientFileTestIT() throws SecurityException {
+    String ip = System.getProperty("nfd.ip");
+    logger.info("Testing on NFD at: " + ip);
+    environment = TestHelper.buildTestEnvironment(ip, 2);
+  }
+
+  @Test
+  public void stressTest() throws Exception {
+    Face producer = environment.faces.get(0);
+    Face consumer = environment.faces.get(1);
+
+    producer.registerPrefix(PREFIX, new AdvancedDataServer(MESSAGE_SIZE_BYTES, SEGMENT_SIZE_BYTES), null);
+
+    // TODO this must be here until the prefix registration callback is complete
+    Thread.sleep(500);
+
+    long startTime = System.currentTimeMillis();
+    AdvancedClient client = new AdvancedClient();
+    List<CompletableFuture<Data>> requests = expressInterests(client, consumer, PREFIX, NUM_MESSAGES);
+    List<Data> datas = requests.stream().map((f) -> TestHelper.retrieve(f)).collect(Collectors.toList());
+    long endTime = System.currentTimeMillis();
+
+    logger.info(String.format("Transfered %d bytes in %d ms", MESSAGE_SIZE_BYTES * NUM_MESSAGES, endTime - startTime));
+  }
+
+  private List<CompletableFuture<Data>> expressInterests(Client client, Face face, Name name, int count) {
+    return IntStream.range(0, count).boxed().map((i) -> client.getAsync(face, name)).collect(Collectors.toList());
+  }
+
+  private class AdvancedDataServer implements OnInterestCallback {
+
+    private final int contentSize;
+    private final int segmentSize;
+
+    public AdvancedDataServer(int contentSize, int segmentSize) {
+      this.contentSize = contentSize;
+      this.segmentSize = segmentSize;
+    }
+
+    @Override
+    public void onInterest(Name prefix, Interest interest, Face face, long interestFilterId, InterestFilter filter) {
+      // ignore segmented requests, the data has already been put below
+      if (SegmentationHelper.isSegmented(interest.getName(), (byte) 0x00)) {
+        return;
+      }
+      
+      // randomly ignore 10% of requests
+      if (new Random().nextInt(10) < 2){
+        logger.info("Skipping an interest: " + interest.toUri());
+        return;
+      }
+
+      ByteArrayInputStream bytes = new ByteArrayInputStream(TestHelper.buildRandomString(contentSize).getBytes());
+      Data data = TestHelper.buildData(interest.getName(), "");
+      data.getMetaInfo().setFreshnessPeriod(0);
+
+      try {
+        for (Data segment : SegmentedServerHelper.segment(data, bytes, segmentSize)) {
+          logger.log(Level.INFO, "Put data: " + segment.getName().toUri());
+          face.putData(segment);
+        }
+      } catch (IOException ex) {
+        logger.log(Level.SEVERE, "Failed to put data.", ex);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientStressTestIT.java b/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientStressTestIT.java
new file mode 100644
index 0000000..6a99599
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/client/impl/AdvancedClientStressTestIT.java
@@ -0,0 +1,118 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 3, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+package com.intel.jndn.utils.client.impl;
+
+import com.intel.jndn.utils.Client;
+import com.intel.jndn.utils.TestHelper;
+import com.intel.jndn.utils.server.impl.SegmentedServerHelper;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import net.named_data.jndn.Data;
+import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.InterestFilter;
+import net.named_data.jndn.Name;
+import net.named_data.jndn.OnInterestCallback;
+import net.named_data.jndn.security.SecurityException;
+import org.junit.Test;
+
+/**
+ * Test AdvancedClient.java; requires a hostname to an NFD accepting a generated
+ * key to register prefixes, e.g. mvn test -Dnfd.ip=10.10.10.1
+ *
+ * @author Andrew Brown <andrew.brown@intel.com>
+ */
+public class AdvancedClientStressTestIT {
+
+  private static final Logger logger = Logger.getLogger(AdvancedClientStressTestIT.class.getName());
+  private static final Name PREFIX = new Name("/test/advanced-client").append(TestHelper.buildRandomString(10));
+  private static final int NUM_MESSAGES = 100;
+  private static final int MESSAGE_SIZE_BYTES = 10000;
+  private static final int SEGMENT_SIZE_BYTES = 5000;
+  private final TestHelper.NdnEnvironment environment;
+
+  public AdvancedClientStressTestIT() throws SecurityException {
+    String ip = System.getProperty("nfd.ip");
+    logger.info("Testing on NFD at: " + ip);
+    environment = TestHelper.buildTestEnvironment(ip, 2);
+  }
+
+  @Test
+  public void stressTest() throws Exception {
+    Face producer = environment.faces.get(0);
+    Face consumer = environment.faces.get(1);
+
+    producer.registerPrefix(PREFIX, new RandomDataServer(MESSAGE_SIZE_BYTES, SEGMENT_SIZE_BYTES), null);
+
+    // TODO this must be here until the prefix registration callback is complete
+    Thread.sleep(500);
+
+    long startTime = System.currentTimeMillis();
+    AdvancedClient client = new AdvancedClient();
+    List<CompletableFuture<Data>> requests = expressInterests(client, consumer, PREFIX, NUM_MESSAGES);
+    List<Data> datas = requests.stream().map((f) -> TestHelper.retrieve(f)).collect(Collectors.toList());
+    long endTime = System.currentTimeMillis();
+
+    logger.info(String.format("Transfered %d bytes in %d ms", MESSAGE_SIZE_BYTES * NUM_MESSAGES, endTime - startTime));
+  }
+
+  private List<CompletableFuture<Data>> expressInterests(Client client, Face face, Name name, int count) {
+    return IntStream.range(0, count).boxed().map((i) -> client.getAsync(face, name)).collect(Collectors.toList());
+  }
+
+  private class RandomDataServer implements OnInterestCallback {
+
+    private final int contentSize;
+    private final int segmentSize;
+
+    public RandomDataServer(int contentSize, int segmentSize) {
+      this.contentSize = contentSize;
+      this.segmentSize = segmentSize;
+    }
+
+    @Override
+    public void onInterest(Name prefix, Interest interest, Face face, long interestFilterId, InterestFilter filter) {
+      // ignore segmented requests, the data has already been put below
+      if (SegmentationHelper.isSegmented(interest.getName(), (byte) 0x00)) {
+        return;
+      }
+      
+      // randomly ignore 10% of requests
+      if (new Random().nextInt(10) < 2){
+        logger.info("Skipping an interest: " + interest.toUri());
+        return;
+      }
+
+      ByteArrayInputStream bytes = new ByteArrayInputStream(TestHelper.buildRandomString(contentSize).getBytes());
+      Data data = TestHelper.buildData(interest.getName(), "");
+      data.getMetaInfo().setFreshnessPeriod(0);
+
+      try {
+        for (Data segment : SegmentedServerHelper.segment(data, bytes, segmentSize)) {
+          logger.log(Level.INFO, "Put data: " + segment.getName().toUri());
+          face.putData(segment);
+        }
+      } catch (IOException ex) {
+        logger.log(Level.SEVERE, "Failed to put data.", ex);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/DefaultSegmentedClientTest.java b/src/test/java/com/intel/jndn/utils/client/impl/DefaultSegmentedClientTest.java
index 7ed72d4..2d65724 100644
--- a/src/test/java/com/intel/jndn/utils/client/impl/DefaultSegmentedClientTest.java
+++ b/src/test/java/com/intel/jndn/utils/client/impl/DefaultSegmentedClientTest.java
@@ -22,8 +22,6 @@
 import net.named_data.jndn.Interest;
 import net.named_data.jndn.Name;
 import static org.junit.Assert.assertEquals;
-
-import net.named_data.jndn.OnData;
 import org.junit.Test;
 
 /**
@@ -42,12 +40,9 @@
     Interest interest = new Interest(name);
     DataStream stream = instance.getSegmentsAsync(face, interest);
 
-    final TestCounter counter = new TestCounter();
-    stream.observe(new OnData() {
-      @Override
-      public void onData(Interest interest, Data data) {
-        counter.count++;
-      }
+    TestCounter counter = new TestCounter();
+    stream.observe((i, d) -> {
+      counter.count++;
     });
 
     for (Data segment : TestHelper.buildSegments(name, 0, 5)) {
@@ -82,12 +77,9 @@
     Interest interest = new Interest(name);
     DataStream stream = instance.getSegmentsAsync(face, interest);
 
-    final TestCounter counter = new TestCounter();
-    stream.observe(new OnData() {
-      @Override
-      public void onData(Interest interest, Data data) {
-        counter.count++;
-      }
+    TestCounter counter = new TestCounter();
+    stream.observe((i, d) -> {
+      counter.count++;
     });
 
     for (Data segment : TestHelper.buildSegments(name, 0, 5)) {
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/SegmentedDataStreamTest.java b/src/test/java/com/intel/jndn/utils/client/impl/SegmentedDataStreamTest.java
index 9407cfc..2f165b9 100644
--- a/src/test/java/com/intel/jndn/utils/client/impl/SegmentedDataStreamTest.java
+++ b/src/test/java/com/intel/jndn/utils/client/impl/SegmentedDataStreamTest.java
@@ -20,7 +20,6 @@
 import net.named_data.jndn.Interest;
 import net.named_data.jndn.Name;
 import net.named_data.jndn.Name.Component;
-import net.named_data.jndn.OnData;
 import net.named_data.jndn.encoding.EncodingException;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
@@ -51,16 +50,13 @@
   public void testAddingUnorderedData() throws StreamException {
     Name name = new Name("/test/segmented/data/stream");
     Interest interest = new Interest(name);
-    final ArrayList<Long> segments = new ArrayList<>();
+    ArrayList<Long> segments = new ArrayList<>();
 
-    instance.observe(new OnData() {
-      @Override
-      public void onData(Interest i, Data d) {
-        try {
-          segments.add(d.getName().get(-1).toSegment());
-        } catch (EncodingException ex) {
-          throw new RuntimeException(ex);
-        }
+    instance.observe((i, d) -> {
+      try {
+        segments.add(d.getName().get(-1).toSegment());
+      } catch (EncodingException ex) {
+        throw new RuntimeException(ex);
       }
     });
 
@@ -103,10 +99,10 @@
   @Test
   public void testOrderedPackets() {
     int end = 10;
-    for (int i = 0; i < end; i++) {
+    IntStream.range(0, end).forEach((i) -> {
       addPacketToInstance(i);
       assertEquals(i, instance.current());
-    };
+    });
 
     assertEquals(end, instance.list().length);
   }
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/SimpleClientTestIT.java b/src/test/java/com/intel/jndn/utils/client/impl/SimpleClientTestIT.java
new file mode 100644
index 0000000..f49525b
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/client/impl/SimpleClientTestIT.java
@@ -0,0 +1,135 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 3, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+package com.intel.jndn.utils.client.impl;
+
+import com.intel.jndn.utils.client.impl.SimpleClient;
+import com.intel.jndn.utils.TestHelper;
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import net.named_data.jndn.Data;
+import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.InterestFilter;
+import net.named_data.jndn.Name;
+import net.named_data.jndn.OnInterestCallback;
+import net.named_data.jndn.security.SecurityException;
+import net.named_data.jndn.util.Blob;
+import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Test;
+
+/**
+ * Test SimpleClient.java; requires a hostname to an NFD accepting a generated
+ * key to register prefixes, e.g. mvn test -Dnfd.ip=10.10.10.1
+ *
+ * @author Andrew Brown <andrew.brown@intel.com>
+ */
+public class SimpleClientTestIT {
+
+  private static final Logger logger = Logger.getLogger(SimpleClientTestIT.class.getName());
+  private static final Name PREFIX_RETRIEVE = new Name("/test/simple-client/retrieve-one").append(TestHelper.buildRandomString(10));
+  private static final Name PREFIX_RETRIEVE_MULTIPLE = new Name("/test/simple-client/retrieve-multiple").append(TestHelper.buildRandomString(10));
+
+  SimpleClient instance;
+  private final TestHelper.NdnEnvironment environment;
+
+  public SimpleClientTestIT() throws SecurityException {
+    String ip = System.getProperty("nfd.ip");
+    environment = TestHelper.buildTestEnvironment(ip, 2);
+    instance = SimpleClient.getDefault();
+  }
+
+  @Test
+  public void testRetrieval() throws Exception {
+    // setup faces
+    Face producerFace = environment.faces.get(0);
+    Face consumerFace = environment.faces.get(1);
+
+    // setup server
+    Data servedData = new Data();
+    servedData.setContent(new Blob("....."));
+    servedData.getMetaInfo().setFreshnessPeriod(0);
+    producerFace.registerPrefix(PREFIX_RETRIEVE, new DataServer(servedData), null);
+
+    // TODO this must be here until the prefix registration callback is complete
+    Thread.sleep(500);
+
+    // send interest
+    CompletableFuture<Data> future = instance.getAsync(consumerFace, PREFIX_RETRIEVE);
+    Data retrievedData = future.get();
+
+    // verify
+    Assert.assertEquals(servedData.getContent().toString(), retrievedData.getContent().toString());
+  }
+
+  @Test
+  public void testSyncRetrieval() throws Exception {
+    String ip = System.getProperty("nfd.ip");
+    Face face = new Face(ip);
+    Interest interest = new Interest(new Name("/localhop/nfd/rib")); // this query should return some data if NFD is running locally
+    interest.setInterestLifetimeMilliseconds(2000);
+    Data data = SimpleClient.getDefault().getSync(face, interest);
+    assertNotNull(data);
+  }
+
+  @Test
+  public void testMultipleRetrieval() throws Exception {
+    int numInterests = 100;
+
+    // setup faces
+    Face producerFace = environment.faces.get(0);
+    Face consumerFace = environment.faces.get(1);
+
+    // setup server
+    Data servedData = new Data();
+    servedData.setContent(new Blob("0123456789"));
+    servedData.getMetaInfo().setFreshnessPeriod(0);
+    producerFace.registerPrefix(PREFIX_RETRIEVE_MULTIPLE, new DataServer(servedData), null);
+
+    // this must be here until the prefix registration callback is complete
+    Thread.sleep(500);
+
+    // request all packets
+    Stream<CompletableFuture<Data>> futures = IntStream.range(0, numInterests)
+            .boxed().map((i) -> instance.getAsync(consumerFace, PREFIX_RETRIEVE_MULTIPLE));
+
+    // check all returned packets
+    futures.map((f) -> TestHelper.retrieve(f))
+            .forEach((d) -> assertEquals(servedData.getContent().toString(), d.getContent().toString()));
+  }
+
+  private class DataServer implements OnInterestCallback {
+
+    private Data data;
+
+    public DataServer(Data data) {
+      this.data = data;
+    }
+
+    @Override
+    public void onInterest(Name prefix, Interest interest, Face face, long interestFilterId, InterestFilter filter) {
+      data.setName(interest.getName());
+      try {
+        face.putData(data);
+      } catch (IOException ex) {
+        logger.log(Level.SEVERE, "Failed to put data.", ex);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/intel/jndn/utils/server/impl/SegmentedServerTestIT.java b/src/test/java/com/intel/jndn/utils/server/impl/SegmentedServerTestIT.java
new file mode 100644
index 0000000..a3409a3
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/server/impl/SegmentedServerTestIT.java
@@ -0,0 +1,104 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 3, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+package com.intel.jndn.utils.server.impl;
+
+import com.intel.jndn.mock.MockKeyChain;
+import com.intel.jndn.utils.TestHelper;
+import com.intel.jndn.utils.client.impl.AdvancedClient;
+import java.io.IOException;
+import java.util.logging.Logger;
+import net.named_data.jndn.Data;
+import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.Name;
+import net.named_data.jndn.encoding.EncodingException;
+import net.named_data.jndn.security.KeyChain;
+import net.named_data.jndn.security.SecurityException;
+import net.named_data.jndn.util.Blob;
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+/**
+ * Test the {@link SegmentedServer} on an actual NFD; to run this, pass the NFD
+ * IP/host name as a parameter like <code>-Dnfd.ip=10.1.1.1</code>.
+ *
+ * @author Andrew Brown <andrew.brown@intel.com>
+ */
+public class SegmentedServerTestIT {
+
+  private static final Logger logger = Logger.getLogger(SegmentedServerTestIT.class.getName());
+  private static final Name PREFIX = new Name("/test/for/segmented-server");
+  protected static final int DATA_SIZE_BYTES = 10000;
+  Face face;
+  SegmentedServer instance;
+  private String ip;
+
+  public SegmentedServerTestIT() throws SecurityException {
+    this.ip = System.getProperty("nfd.ip");
+    this.face = new Face(ip);
+    this.instance = new SegmentedServer(face, PREFIX);
+    KeyChain mockKeyChain = MockKeyChain.configure(new Name("/test/server"));
+    face.setCommandSigningInfo(mockKeyChain, mockKeyChain.getDefaultCertificateName());
+  }
+
+  @Test
+  public void testRegisterAndRetrieval() throws Exception {
+    final Name dataName = new Name(PREFIX).append("1");
+
+    // why a new thread? The server will only operate if someone turns the crank,
+    // i.e. someone calls face.processEvents() every so often. 
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          instance.serve(buildDataPacket(dataName));
+        } catch (IOException ex) {
+          logger.info("Failed to serve data.");
+        }
+
+        while (true) {
+          try {
+            face.processEvents();
+          } catch (IOException | EncodingException ex) {
+            logger.info("Failed while processing events.");
+          }
+        }
+      }
+    }).start();
+
+    // TODO why wait? we want to make sure the thread is running and that the prefix
+    // registration has succeeded on the NFD before we send interests
+    Thread.sleep(1000);
+
+    // why a different face? because we don't want the abover face.processEvents()
+    // to interfere with the SimpleClient's processEvents().
+    logger.info("Retrieving data: " + dataName.toUri());
+    Interest interest = new Interest(dataName);
+    interest.setInterestLifetimeMilliseconds(2000);
+    interest.setMustBeFresh(true);
+    interest.setChildSelector(Interest.CHILD_SELECTOR_RIGHT);
+
+    Data retrieved = AdvancedClient.getDefault().getSync(new Face(ip), interest);
+    assertNotNull(retrieved);
+    assertEquals(DATA_SIZE_BYTES, retrieved.getContent().size());
+    logger.info("Retrieved data: " + retrieved.getName().toUri());
+  }
+
+  Data buildDataPacket(Name name) {
+    Data data = new Data(new Name(name).appendSegment(0));
+    data.setContent(new Blob(TestHelper.buildRandomBytes(DATA_SIZE_BYTES)));
+    data.getMetaInfo().setFreshnessPeriod(30000);
+    return data;
+  }
+}