diff --git a/src/main/java/com/intel/jndn/utils/ContentStore.java b/src/main/java/com/intel/jndn/utils/ContentStore.java
index f446dea..e0ccc51 100644
--- a/src/main/java/com/intel/jndn/utils/ContentStore.java
+++ b/src/main/java/com/intel/jndn/utils/ContentStore.java
@@ -15,10 +15,12 @@
 package com.intel.jndn.utils;
 
 import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
 import net.named_data.jndn.Name;
 import net.named_data.jndn.util.Blob;
 
 import java.io.IOException;
+import java.util.Optional;
 
 /**
  * TODO merge with Repository
@@ -43,12 +45,28 @@
   boolean has(Name name);
 
   /**
+   * Check if the content exists
+   *
+   * @param interest a selector-enabled interest to search for content in the store
+   * @return true if the content exists
+   */
+  boolean has(Interest interest);
+
+  /**
    * Retrieve the content by name
    *
    * @param name the name of the content
-   * @return the content if it exists or null otherwise TODO throw instead? Optional?
+   * @return the content if it exists
    */
-  Blob get(Name name);
+  Optional<Blob> get(Name name);
+
+  /**
+   * Retrieve the content by name
+   *
+   * @param interest the name of the content
+   * @return the content if it exists
+   */
+  Optional<Blob> get(Interest interest);
 
   /**
    * Write the stored content to the face as Data packets. If no content exists for the given name, this method should
@@ -61,6 +79,16 @@
   void push(Face face, Name name) throws IOException;
 
   /**
+   * Write the stored content to the face as Data packets. If no content exists for the given name, this method should
+   * have no effect.
+   *
+   * @param face the face to write to
+   * @param interest the interest identifying of the data to write
+   * @throws IOException if the writing fails
+   */
+  void push(Face face, Interest interest) throws IOException;
+
+  /**
    * Remove all stored content
    */
   void clear();
diff --git a/src/main/java/com/intel/jndn/utils/NameTree.java b/src/main/java/com/intel/jndn/utils/NameTree.java
new file mode 100644
index 0000000..8ae4fcc
--- /dev/null
+++ b/src/main/java/com/intel/jndn/utils/NameTree.java
@@ -0,0 +1,45 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2016, 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;
+
+import net.named_data.jndn.Name;
+
+import java.util.Collection;
+import java.util.Optional;
+
+/**
+ * @author Andrew Brown, andrew.brown@intel.com
+ */
+public interface NameTree<T> {
+  Optional<T> content();
+
+  Name.Component lastComponent();
+
+  Name fullName();
+
+  Collection<NameTree<T>> children();
+
+  NameTree<T> parent();
+
+  NameTree<T> insert(Name name, T content);
+
+  Optional<NameTree<T>> find(Name query);
+
+  Optional<NameTree<T>> delete(Name name);
+
+  int count();
+
+  void clear();
+}
diff --git a/src/main/java/com/intel/jndn/utils/client/RetryClient.java b/src/main/java/com/intel/jndn/utils/client/RetryClient.java
index b559802..432db0b 100644
--- a/src/main/java/com/intel/jndn/utils/client/RetryClient.java
+++ b/src/main/java/com/intel/jndn/utils/client/RetryClient.java
@@ -11,6 +11,7 @@
  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  * more details.
  */
+
 package com.intel.jndn.utils.client;
 
 import net.named_data.jndn.Face;
@@ -21,7 +22,8 @@
 import java.io.IOException;
 
 /**
- * Define a client that can retry {@link Interest} packets on timeout.
+ * Define a client that can retry {@link Interest} packets on timeout. TODO should return Cancellation so that users
+ * can stop the process
  *
  * @author Andrew Brown, andrew.brown@intel.com
  */
diff --git a/src/main/java/com/intel/jndn/utils/client/impl/BackoffRetryClient.java b/src/main/java/com/intel/jndn/utils/client/impl/BackoffRetryClient.java
new file mode 100644
index 0000000..ca8357f
--- /dev/null
+++ b/src/main/java/com/intel/jndn/utils/client/impl/BackoffRetryClient.java
@@ -0,0 +1,66 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2016, 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.RetryClient;
+import net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.OnData;
+import net.named_data.jndn.OnTimeout;
+
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * @author Andrew Brown, andrew.brown@intel.com
+ */
+public class BackoffRetryClient implements RetryClient {
+
+  private static final Logger LOGGER = Logger.getLogger(BackoffRetryClient.class.getName());
+  private final double cutoffLifetime;
+  private final int backoffFactor;
+
+  public BackoffRetryClient(double cutoffLifetime, int backoffFactor) {
+    this.cutoffLifetime = cutoffLifetime;
+    this.backoffFactor = backoffFactor;
+  }
+
+  @Override
+  public void retry(Face face, Interest interest, OnData onData, OnTimeout onTimeout) throws IOException {
+    retryInterest(face, interest, onData, onTimeout);
+  }
+
+  private void retryInterest(Face face, Interest interest, OnData onData, OnTimeout onTimeout) throws IOException {
+    double newLifetime = interest.getInterestLifetimeMilliseconds() * backoffFactor;
+    if (newLifetime < cutoffLifetime) {
+      interest.setInterestLifetimeMilliseconds(newLifetime);
+      resend(face, interest, onData, onTimeout);
+    } else {
+      onTimeout.onTimeout(interest);
+    }
+  }
+
+  private void resend(Face face, Interest interest, OnData onData, OnTimeout onTimeout) throws IOException {
+    LOGGER.log(Level.INFO, "Resending interest with {0}ms lifetime: {1}", new Object[]{interest.getInterestLifetimeMilliseconds(), interest.getName()});
+    face.expressInterest(interest, onData, timedOutInterest -> {
+      try {
+        retryInterest(face, timedOutInterest, onData, onTimeout);
+      } catch (IOException e) {
+        onTimeout.onTimeout(interest);
+      }
+    });
+  }
+}
diff --git a/src/main/java/com/intel/jndn/utils/client/impl/DefaultRetryClient.java b/src/main/java/com/intel/jndn/utils/client/impl/DefaultRetryClient.java
index de85eb6..cb90496 100644
--- a/src/main/java/com/intel/jndn/utils/client/impl/DefaultRetryClient.java
+++ b/src/main/java/com/intel/jndn/utils/client/impl/DefaultRetryClient.java
@@ -1,6 +1,6 @@
 /*
  * jndn-utils
- * Copyright (c) 2015, Intel Corporation.
+ * Copyright (c) 2016, 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,
@@ -31,7 +31,7 @@
  */
 public class DefaultRetryClient implements RetryClient {
 
-  private static final Logger logger = Logger.getLogger(DefaultRetryClient.class.getName());
+  private static final Logger LOGGER = Logger.getLogger(DefaultRetryClient.class.getName());
   private final int numRetriesAllowed;
   private volatile int totalRetries = 0;
 
@@ -62,8 +62,8 @@
    * @param context the current request context
    * @throws IOException when the client cannot perform the necessary network IO
    */
-  synchronized private void retryInterest(RetryContext context) throws IOException {
-    logger.info("Retrying interest: " + context.interest.toUri());
+  private synchronized void retryInterest(RetryContext context) throws IOException {
+    LOGGER.info("Retrying interest: " + context.interest.toUri());
     context.face.expressInterest(context.interest, context, context);
     totalRetries++;
   }
@@ -71,7 +71,7 @@
   /**
    * @return the total number of retries logged by this client
    */
-  public int totalRetries() {
+  int totalRetries() {
     return totalRetries;
   }
 
@@ -81,20 +81,20 @@
    */
   private class RetryContext implements OnData, OnTimeout {
 
-    public final Face face;
-    public final Interest interest;
-    public final OnData applicationOnData;
-    public final OnTimeout applicationOnTimeout;
-    public int numFailures = 0;
+    final Face face;
+    final Interest interest;
+    final OnData applicationOnData;
+    final OnTimeout applicationOnTimeout;
+    int numFailures = 0;
 
-    public RetryContext(Face face, Interest interest, OnData applicationOnData, OnTimeout applicationOnTimeout) {
+    RetryContext(Face face, Interest interest, OnData applicationOnData, OnTimeout applicationOnTimeout) {
       this.face = face;
       this.interest = interest;
       this.applicationOnData = applicationOnData;
       this.applicationOnTimeout = applicationOnTimeout;
     }
 
-    public boolean shouldRetry() {
+    boolean shouldRetry() {
       return numFailures < numRetriesAllowed;
     }
 
@@ -106,7 +106,7 @@
     @Override
     public void onTimeout(Interest interest) {
       numFailures++;
-      logger.finest("Request failed, count " + numFailures + ": " + interest.toUri());
+      LOGGER.finest("Request failed, count " + numFailures + ": " + interest.toUri());
 
       if (shouldRetry()) {
         try {
diff --git a/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStore.java b/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStore.java
index 477a573..5b269bf 100644
--- a/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStore.java
+++ b/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStore.java
@@ -15,49 +15,140 @@
 package com.intel.jndn.utils.impl;
 
 import com.intel.jndn.utils.ContentStore;
+import com.intel.jndn.utils.NameTree;
 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.util.Blob;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
 
 /**
  * @author Andrew Brown, andrew.brown@intel.com
  */
 public class BoundedInMemoryContentStore implements ContentStore {
-  private final BoundedLinkedMap<Name, Blob> store;
+  private final NameTree<Blob> store;
   private final Data template;
 
   public BoundedInMemoryContentStore(int maxSize, int freshnessMs) {
-    this.store = new BoundedLinkedMap<>(maxSize);
     this.template = new Data();
     this.template.getMetaInfo().setFreshnessPeriod(freshnessMs);
+    this.store = DefaultNameTree.newRootTree();
   }
 
   @Override
   public void put(Name name, Blob data) {
-    store.put(name, data);
+    store.insert(name, data);
+  }
+
+  @Override
+  public Optional<Blob> get(Interest interest) {
+    Optional<NameTree<Blob>> possibleBlob = store.find(interest.getName());
+    if (!possibleBlob.isPresent()) {
+      return Optional.empty();
+    } else if (hasSelectors(interest)) {
+      List<NameTree<Blob>> children = new ArrayList<>(possibleBlob.get().children());
+      if (children.isEmpty()) {
+        return Optional.empty();
+      } else if (children.size() == 1) {
+        return children.get(0).content();
+      } else {
+        if (isRightMost(interest)) {
+          Collections.sort(children, (a, b) -> b.lastComponent().compare(a.lastComponent()));
+        } else if (isLeftMost(interest)) {
+          Collections.sort(children, (a, b) -> a.lastComponent().compare(b.lastComponent()));
+        }
+        return children.get(0).content();
+      }
+
+      // TODO max min suffix components
+
+    } else {
+      return possibleBlob.get().content();
+    }
+  }
+
+  // TODO merge with above
+  private Optional<NamePair> getNamePair(Interest interest) {
+    Optional<NameTree<Blob>> possibleBlob = store.find(interest.getName());
+    if (!possibleBlob.isPresent()) {
+      return Optional.empty();
+    } else if (hasSelectors(interest)) {
+      List<NameTree<Blob>> children = new ArrayList<>(possibleBlob.get().children());
+      if (children.isEmpty()) {
+        return Optional.empty();
+      } else if (children.size() == 1) {
+        return NamePair.fromContent(children.get(0));
+      } else {
+        if (isRightMost(interest)) {
+          Collections.sort(children, (a, b) -> b.lastComponent().compare(a.lastComponent()));
+        } else if (isLeftMost(interest)) {
+          Collections.sort(children, (a, b) -> a.lastComponent().compare(b.lastComponent()));
+        }
+        return NamePair.fromContent(children.get(0));
+      }
+
+      // TODO max min suffix components
+
+    } else {
+      return NamePair.fromContent(possibleBlob.get());
+    }
+  }
+
+  private boolean hasSelectors(Interest interest) {
+    return interest.getChildSelector() != -1 || interest.getExclude().size() > 0;
+  }
+
+  private boolean isRightMost(Interest interest) {
+    return interest.getChildSelector() == Interest.CHILD_SELECTOR_RIGHT;
+  }
+
+  private boolean isLeftMost(Interest interest) {
+    return interest.getChildSelector() == Interest.CHILD_SELECTOR_LEFT;
   }
 
   @Override
   public boolean has(Name name) {
-    return store.containsKey(name);
+    return store.find(name).isPresent();
   }
 
   @Override
-  public Blob get(Name name) {
-    return store.get(name);
+  public boolean has(Interest interest) {
+    return get(interest).isPresent();
+  }
+
+  @Override
+  public Optional<Blob> get(Name name) {
+    Optional<NameTree<Blob>> tree = store.find(name);
+    return tree.isPresent() ? tree.get().content() : Optional.empty();
   }
 
   @Override
   public void push(Face face, Name name) throws IOException {
-    Blob blob = get(name);
-    if (blob != null) {
+    Optional<Blob> blob = get(name);
+    if (blob.isPresent()) {
       Data t = new Data(template);
       t.setName(name);
-      ByteArrayInputStream b = new ByteArrayInputStream(blob.getImmutableArray());
+      ByteArrayInputStream b = new ByteArrayInputStream(blob.get().getImmutableArray());
+      for (Data d : SegmentationHelper.segment(t, b)) {
+        face.putData(d);
+      }
+    }
+  }
+
+  @Override
+  public void push(Face face, Interest interest) throws IOException {
+    Optional<NamePair> pair = getNamePair(interest);
+    if (pair.isPresent()) {
+      Data t = new Data(template);
+      t.setName(pair.get().name);
+      ByteArrayInputStream b = new ByteArrayInputStream(pair.get().blob.getImmutableArray());
       for (Data d : SegmentationHelper.segment(t, b)) {
         face.putData(d);
       }
@@ -68,4 +159,23 @@
   public void clear() {
     store.clear();
   }
+
+  private static class NamePair {
+    public final Name name;
+    public final Blob blob;
+
+    public NamePair(Name name, Blob blob) {
+      this.name = name;
+      this.blob = blob;
+    }
+
+    static Optional<NamePair> fromContent(NameTree<Blob> leaf) {
+      Optional<Blob> content = leaf.content();
+      if (content.isPresent()) {
+        return Optional.of(new NamePair(leaf.fullName(), leaf.content().get()));
+      } else {
+        return Optional.empty();
+      }
+    }
+  }
 }
diff --git a/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryPendingInterestTable.java b/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryPendingInterestTable.java
index b214019..460d08f 100644
--- a/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryPendingInterestTable.java
+++ b/src/main/java/com/intel/jndn/utils/impl/BoundedInMemoryPendingInterestTable.java
@@ -19,13 +19,15 @@
 import net.named_data.jndn.Name;
 
 import java.util.Collection;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
 /**
  * @author Andrew Brown, andrew.brown@intel.com
  */
 public class BoundedInMemoryPendingInterestTable implements PendingInterestTable {
-  //private static final Logger LOGGER = Logger.getLogger(BoundedInMemoryPendingInterestTable.class.getName());
+  private static final Logger LOGGER = Logger.getLogger(BoundedInMemoryPendingInterestTable.class.getName());
   private final BoundedLinkedMap<Name, Interest> table;
 
   public BoundedInMemoryPendingInterestTable(int maxSize) {
@@ -34,6 +36,7 @@
 
   @Override
   public void add(Interest interest) {
+    LOGGER.log(Level.INFO, "Adding pending interest: {0}", interest.toUri());
     table.put(interest.getName(), interest);
   }
 
diff --git a/src/main/java/com/intel/jndn/utils/impl/DefaultNameTree.java b/src/main/java/com/intel/jndn/utils/impl/DefaultNameTree.java
new file mode 100644
index 0000000..5916cc3
--- /dev/null
+++ b/src/main/java/com/intel/jndn/utils/impl/DefaultNameTree.java
@@ -0,0 +1,145 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2016, 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.impl;
+
+import com.intel.jndn.utils.NameTree;
+import net.named_data.jndn.Name;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * // TODO need a way to bound the size
+ * @author Andrew Brown, andrew.brown@intel.com
+ */
+public class DefaultNameTree<T> implements NameTree<T> {
+  private final DefaultNameTree<T> parent;
+  private final Map<Name.Component, DefaultNameTree<T>> children = new HashMap<>();
+  private Name.Component component;
+  private T content;
+
+  DefaultNameTree(DefaultNameTree<T> parent) {
+    this.parent = parent;
+  }
+
+  public static <T> NameTree<T> newRootTree() {
+    return new DefaultNameTree<>(null);
+  }
+
+  @Override
+  public Optional<T> content() {
+    return Optional.ofNullable(content);
+  }
+
+  @Override
+  public Name fullName() {
+    throw new UnsupportedOperationException("Need recursive call");
+  }
+
+  @Override
+  public Name.Component lastComponent() {
+    return component;
+  }
+
+  @Override
+  public Collection<NameTree<T>> children() {
+    List<NameTree<T>> c = new ArrayList<>(children.size());
+    for (NameTree<T> nt : children.values()) {
+      c.add(nt);
+    }
+    return c;
+  }
+
+  @Override
+  public NameTree<T> parent() {
+    return parent;
+  }
+
+  @Override
+  public Optional<NameTree<T>> find(Name name) {
+    if (name.size() == 0) {
+      return Optional.of(this);
+    } else {
+      Name.Component first = name.get(0);
+      DefaultNameTree<T> child = children.get(first);
+      if (child == null) {
+        return Optional.empty();
+      } else {
+        return child.find(name.size() > 1 ? name.getSubName(-1) : new Name());
+      }
+    }
+  }
+
+  @Override
+  public NameTree<T> insert(Name name, T content) {
+    Name.Component first = name.get(0);
+
+    DefaultNameTree<T> child = children.get(first);
+    if (child == null) {
+      child = new DefaultNameTree<>(this);
+      child.component = first;
+      children.put(first, child);
+    }
+
+    if (name.size() == 1) {
+      child.content = content;
+      return child;
+    } else {
+      return child.insert(name.getSubName(1), content);
+    }
+  }
+
+  @Override
+  public Optional<NameTree<T>> delete(Name name) {
+    if (name.size() == 0) {
+      return Optional.of(parent.deleteChild(this.component));
+    } else {
+      Name.Component first = name.get(0);
+      DefaultNameTree<T> child = children.get(first);
+      if (child == null) {
+        return Optional.empty();
+      } else {
+        if (children.size() == 1) {
+          children.remove(first);
+        }
+        return child.delete(name.getSubName(1));
+      }
+    }
+  }
+
+  private NameTree<T> deleteChild(Name.Component component) {
+    return children.remove(component);
+  }
+
+  @Override
+  public int count() {
+    throw new UnsupportedOperationException("Breadth-first search?");
+  }
+
+  @Override
+  public void clear() {
+    children.clear();
+  }
+
+  @Override
+  public String toString() {
+    String c = (component == null) ? null : component.toEscapedString();
+    return "DefaultNameTree{" + c + ": " + content + '}';
+  }
+}
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/AnnouncementService.java b/src/main/java/com/intel/jndn/utils/pubsub/AnnouncementService.java
index 4ab03aa..92be1ba 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/AnnouncementService.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/AnnouncementService.java
@@ -22,6 +22,7 @@
 interface AnnouncementService {
   void announceEntrance(long id) throws IOException;
   void announceExit(long id) throws IOException;
-  Cancellation discoverExistingAnnouncements(On<Long> onFound, On<Void> onComplete, On<Exception> onError);
+
+  Cancellation discoverExistingAnnouncements(On<Long> onFound, On<Void> onComplete, On<Exception> onError) throws IOException;
   Cancellation observeNewAnnouncements(On<Long> onAdded, On<Long> onRemoved, On<Exception> onError) throws RegistrationFailureException;
 }
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/NdnAnnouncementService.java b/src/main/java/com/intel/jndn/utils/pubsub/NdnAnnouncementService.java
index 4fa8409..654051f 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/NdnAnnouncementService.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/NdnAnnouncementService.java
@@ -14,6 +14,8 @@
 
 package com.intel.jndn.utils.pubsub;
 
+import com.intel.jndn.utils.client.impl.BackoffRetryClient;
+import net.named_data.jndn.Exclude;
 import net.named_data.jndn.Face;
 import net.named_data.jndn.Interest;
 import net.named_data.jndn.InterestFilter;
@@ -37,17 +39,20 @@
  */
 class NdnAnnouncementService implements AnnouncementService {
   private static final Logger LOGGER = Logger.getLogger(NdnAnnouncementService.class.getName());
+  private static final double STARTING_DISCOVERY_LIFETIME = 100.0;
+  private static final double MAX_DISCOVERY_LIFETIME = 45000.0;
   private final Face face;
-  private final Name broadcastPrefix;
   private final Name topicPrefix;
-  private final Name usablePrefix;
+  private final Name broadcastPrefix;
   private final Set<Long> known = new HashSet<>();
+  private BackoffRetryClient client;
+  private boolean stopped = false;
 
   private NdnAnnouncementService(Face face, Name broadcastPrefix, Name topicPrefix) {
     this.face = face;
-    this.broadcastPrefix = broadcastPrefix;
     this.topicPrefix = topicPrefix;
-    this.usablePrefix = new Name(broadcastPrefix).append(topicPrefix);
+    this.broadcastPrefix = new Name(broadcastPrefix).append(topicPrefix);
+    this.client = new BackoffRetryClient(MAX_DISCOVERY_LIFETIME, 2);
   }
 
   NdnAnnouncementService(Face face, Name topicPrefix) {
@@ -56,22 +61,22 @@
 
   @Override
   public void announceEntrance(long id) throws IOException {
-    LOGGER.log(Level.INFO, "Announcing publisher entrance: {0} to {1}", new Object[]{id, topicPrefix});
-    Name name = PubSubNamespace.toAnnouncement(new Name(broadcastPrefix).append(topicPrefix), id, PubSubNamespace.Announcement.ENTRANCE);
+    LOGGER.log(Level.INFO, "Announcing publisher entrance: {0} to {1}", new Object[]{id, broadcastPrefix});
+    Name name = PubSubNamespace.toAnnouncement(broadcastPrefix, id, PubSubNamespace.Announcement.ENTRANCE);
     Interest interest = new Interest(name);
     face.expressInterest(interest, null);
   }
 
   @Override
   public void announceExit(long id) throws IOException {
-    LOGGER.log(Level.INFO, "Announcing publisher exit: {0} from {1}", new Object[]{id, topicPrefix});
-    Name name = PubSubNamespace.toAnnouncement(new Name(broadcastPrefix).append(topicPrefix), id, PubSubNamespace.Announcement.EXIT);
+    LOGGER.log(Level.INFO, "Announcing publisher exit: {0} from {1}", new Object[]{id, broadcastPrefix});
+    Name name = PubSubNamespace.toAnnouncement(broadcastPrefix, id, PubSubNamespace.Announcement.EXIT);
     Interest interest = new Interest(name);
     face.expressInterest(interest, null);
   }
 
   @Override
-  public Cancellation discoverExistingAnnouncements(On<Long> onFound, On<Void> onComplete, On<Exception> onError) {
+  public Cancellation discoverExistingAnnouncements(On<Long> onFound, On<Void> onComplete, On<Exception> onError) throws IOException {
     LOGGER.log(Level.INFO, "Discover existing publishers: {0}", topicPrefix);
     if (onFound == null) {
       return CANCELLED;
@@ -82,32 +87,68 @@
       onFound.on(id);
     }
 
-    // TODO while !backoff interval maxed out, send out interests with excludes
-    Interest interest = new Interest();
+    discover(client, onFound, onComplete, onError);
+    return () -> stopped = true;
+  }
+
+  private Interest discover(BackoffRetryClient client, On<Long> onFound, On<Void> onComplete, On<Exception> onError) throws IOException {
+    Interest interest = new Interest(topicPrefix);
+    interest.setInterestLifetimeMilliseconds(STARTING_DISCOVERY_LIFETIME);
+    interest.setExclude(excludeKnownPublishers());
+    client.retry(face, interest, (interest1, data) -> {
+      if (stopped) {
+        return;
+      }
+
+      LOGGER.log(Level.INFO, "Received discovery data ({0} bytes): {1}", new Object[]{data.getContent().size(), data.getName()});
+      found(data.getName(), onFound, onError);
+
+      // TODO instead of inspecting name should look at content and examine for multiple publishers
+      try {
+        discover(client, onFound, onComplete, onError); // recursion
+      } catch (IOException e) {
+        LOGGER.log(Level.SEVERE, "Failed while discovering publishers, aborting: {0}", new Object[]{broadcastPrefix, e});
+        onError.on(e);
+        // TODO re-call discover here?
+      }
+    }, interest2 -> {
+      // TODO recall client here, we should never be done
+    });
+    return interest;
+  }
+
+  private Exclude excludeKnownPublishers() {
+    Exclude exclude = new Exclude();
+    for (long pid : known) {
+      exclude.appendComponent(PubSubNamespace.toPublisherComponent(pid));
+    }
+    return exclude;
+  }
+
+  private void found(Name publisherName, On<Long> onFound, On<Exception> onError) {
     try {
-      long pendingInterest = face.expressInterest(interest, (i, d) -> {
-      }, (i) -> {
-      });
-      return () -> face.removePendingInterest(pendingInterest);
-    } catch (IOException e) {
+      found(PubSubNamespace.parsePublisher(publisherName), onFound);
+    } catch (EncodingException e) {
+      LOGGER.log(Level.SEVERE, "Failed to parse new publisher name, ignoring: {0}", publisherName);
       onError.on(e);
-      return CANCELLED;
     }
   }
 
-  private void found(long publisherId) {
+  private void found(long publisherId, On<Long> onFound) {
+    LOGGER.log(Level.INFO, "Found new publisher: {0}", publisherId);
     known.add(publisherId);
+    onFound.on(publisherId);
   }
 
   @Override
   public Cancellation observeNewAnnouncements(On<Long> onAdded, On<Long> onRemoved, On<Exception> onError) throws RegistrationFailureException {
-    LOGGER.log(Level.INFO, "Observing new announcements: {0}", topicPrefix);
+    LOGGER.log(Level.INFO, "Observing new announcements: {0}", broadcastPrefix);
     CompletableFuture<Void> future = new CompletableFuture<>();
     OnRegistration onRegistration = new OnRegistration(future);
     OnAnnouncement onAnnouncement = new OnAnnouncement(onAdded, onRemoved, onError);
 
     try {
-      long registeredPrefix = face.registerPrefix(usablePrefix, onAnnouncement, (OnRegisterFailed) onRegistration, onRegistration);
+      long registeredPrefix = face.registerPrefix(broadcastPrefix, onAnnouncement, (OnRegisterFailed) onRegistration, onRegistration);
       return () -> face.removeRegisteredPrefix(registeredPrefix);
     } catch (IOException | SecurityException e) {
       throw new RegistrationFailureException(e);
@@ -127,8 +168,9 @@
 
     @Override
     public void onInterest(Name name, Interest interest, Face face, long l, InterestFilter interestFilter) {
+      LOGGER.log(Level.INFO, "Received announcement: {0}", interest.toUri());
       try {
-        long publisherId = interest.getName().get(-2).toNumberWithMarker(PubSubNamespace.PUBLISHER_ID_MARKER);
+        long publisherId = PubSubNamespace.parsePublisher(interest.getName());
         PubSubNamespace.Announcement announcement = PubSubNamespace.parseAnnouncement(interest.getName());
         switch (announcement) {
           case ENTRANCE:
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/NdnPublisher.java b/src/main/java/com/intel/jndn/utils/pubsub/NdnPublisher.java
index a6e1b87..48c11bb 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/NdnPublisher.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/NdnPublisher.java
@@ -16,6 +16,7 @@
 
 import com.intel.jndn.utils.ContentStore;
 import com.intel.jndn.utils.Publisher;
+import net.named_data.jndn.Data;
 import net.named_data.jndn.Face;
 import net.named_data.jndn.Interest;
 import net.named_data.jndn.InterestFilter;
@@ -39,6 +40,7 @@
  */
 class NdnPublisher implements Publisher, OnInterestCallback {
   private static final Logger LOGGER = Logger.getLogger(NdnPublisher.class.getName());
+  private static final int ATTRIBUTES_FRESHNESS_PERIOD = 2000;
   private final Face face;
   private final Name prefix;
   private final AnnouncementService announcementService;
@@ -51,7 +53,7 @@
 
   NdnPublisher(Face face, Name prefix, long publisherId, AnnouncementService announcementService, PendingInterestTable pendingInterestTable, ContentStore contentStore) {
     this.face = face;
-    this.prefix = prefix;
+    this.prefix = PubSubNamespace.toPublisherName(prefix, publisherId);
     this.publisherId = publisherId;
     this.announcementService = announcementService;
     this.pendingInterestTable = pendingInterestTable;
@@ -101,26 +103,53 @@
     LOGGER.log(Level.INFO, "Published message {0} to content store: {1}", new Object[]{id, name});
 
     if (pendingInterestTable.has(new Interest(name))) {
-      try {
-        contentStore.push(face, name);
-        // TODO extract satisfied interests
-      } catch (IOException e) {
-        LOGGER.log(Level.SEVERE, "Failed to send message {0} for pending interests: {1}", new Object[]{id, name, e});
-      }
+      sendContent(face, name);
+      // TODO extract satisfied interests
     }
   }
 
   @Override
   public void onInterest(Name name, Interest interest, Face face, long registrationId, InterestFilter interestFilter) {
     LOGGER.log(Level.INFO, "Client requesting message: {0}", interest.toUri());
-    try {
-      if (contentStore.has(interest.getName())) {
-        contentStore.push(face, interest.getName());
+    if (isAttributesRequest(name, interest)) {
+      sendAttributes(face, name);
+    } else {
+      if (contentStore.has(interest)) {
+        sendContent(face, interest);
       } else {
         pendingInterestTable.add(interest);
       }
+    }
+  }
+
+  private boolean isAttributesRequest(Name name, Interest interest) {
+    return name.equals(interest.getName()) && interest.getChildSelector() == -1;
+  }
+
+  private void sendContent(Face face, Name name) {
+    try {
+      contentStore.push(face, name);
     } catch (IOException e) {
-      LOGGER.log(Level.SEVERE, "Failed to publish message for interest: " + interest.toUri(), e);
+      LOGGER.log(Level.SEVERE, "Failed to publish message, aborting: {0}", new Object[]{name, e});
+    }
+  }
+
+  private void sendContent(Face face, Interest interest) {
+    try {
+      contentStore.push(face, interest);
+    } catch (IOException e) {
+      LOGGER.log(Level.SEVERE, "Failed to publish message, aborting: {0}", new Object[]{interest.getName(), e});
+    }
+  }
+
+  private void sendAttributes(Face face, Name publisherName) {
+    Data data = new Data(publisherName);
+    data.setContent(new Blob("[attributes here]"));
+    data.getMetaInfo().setFreshnessPeriod(ATTRIBUTES_FRESHNESS_PERIOD);
+    try {
+      face.putData(data);
+    } catch (IOException e) {
+      LOGGER.log(Level.SEVERE, "Failed to publish attributes for publisher: " + publisherName, e);
     }
   }
 }
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/NdnSubscriber.java b/src/main/java/com/intel/jndn/utils/pubsub/NdnSubscriber.java
index 164dd89..37f71fa 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/NdnSubscriber.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/NdnSubscriber.java
@@ -23,6 +23,7 @@
 import net.named_data.jndn.encoding.EncodingException;
 import net.named_data.jndn.util.Blob;
 
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
@@ -37,29 +38,27 @@
   private static final Logger LOGGER = Logger.getLogger(NdnSubscriber.class.getName());
   private final Face face;
   private final Name prefix;
-  private final On<Blob> onMessage = null;
-  private final On<Exception> onError = null;
+  private final On<Blob> onMessage;
+  private final On<Exception> onError;
   private final AnnouncementService announcementService;
   private final Client client;
   private final Map<Long, Subscription> subscriptions = new HashMap<>();
   private Cancellation newAnnouncementCancellation;
   private Cancellation existingAnnouncementsCancellation;
-  private volatile boolean started = false;
 
-  NdnSubscriber(Face face, Name prefix, AnnouncementService announcementService, Client client) {
+  NdnSubscriber(Face face, Name prefix, On<Blob> onMessage, On<Exception> onError, AnnouncementService announcementService, Client client) {
     this.face = face;
     this.prefix = prefix;
+    this.onMessage = onMessage;
+    this.onError = onError;
     this.announcementService = announcementService;
     this.client = client;
   }
 
-  void open() throws RegistrationFailureException {
+  void open() throws RegistrationFailureException, IOException {
     LOGGER.log(Level.INFO, "Starting subscriber: {0}", prefix);
-
     existingAnnouncementsCancellation = announcementService.discoverExistingAnnouncements(this::add, null, e -> close());
     newAnnouncementCancellation = announcementService.observeNewAnnouncements(this::add, this::remove, e -> close());
-
-    started = true;
   }
 
   void add(long publisherId) {
@@ -92,8 +91,6 @@
     for (Subscription c : subscriptions.values()) {
       c.cancel();
     }
-
-    started = false;
   }
 
   Set<Long> knownPublishers() {
@@ -104,28 +101,27 @@
   // TODO remove this, do topic.subscribe(On..., On...) instead; or new Subscriber(On..., On..., ...).open()
   @Override
   public Cancellation subscribe(On<Blob> onMessage, On<Exception> onError) {
-    if (!started) {
-      try {
-        open();
-      } catch (RegistrationFailureException e) {
-        LOGGER.log(Level.SEVERE, "Failed to start announcement service, aborting subscription", e);
-        onError.on(e);
-        return Cancellation.CANCELLED;
-      }
-    }
-
-    LOGGER.log(Level.INFO, "Subscribing: {0}", prefix);
-    for (Subscription c : subscriptions.values()) {
-      c.subscribe();
-    }
-
+//    if (!started) {
+//      try {
+//        open();
+//      } catch (RegistrationFailureException e) {
+//        LOGGER.log(Level.SEVERE, "Failed to start announcement service, aborting subscription", e);
+//        onError.on(e);
+//        return Cancellation.CANCELLED;
+//      }
+//    }
+//
+//    LOGGER.log(Level.INFO, "Subscribing: {0}", prefix);
+//    for (Subscription c : subscriptions.values()) {
+//      c.subscribe();
+//    }
+//
     return this::close;
   }
 
   private class Subscription implements Cancellation {
     final long publisherId;
     long messageId;
-    boolean subscribed = false;
     CompletableFuture<Data> currentRequest;
 
     Subscription(long publisherId) {
@@ -133,13 +129,9 @@
     }
 
     synchronized void subscribe() {
-      if (subscribed) {
-        return;
-      }
-
+      // would prefer this to be getAsync(on<>, on<>)?
       currentRequest = client.getAsync(face, buildLatestInterest(publisherId)); // TODO backoff
       currentRequest.handle(this::handleResponse);
-      subscribed = true;
     }
 
     @Override
@@ -169,8 +161,8 @@
     }
 
     private void next(long publisherId, long messageId) {
-      CompletableFuture<Data> nextRequest = client.getAsync(face, buildNextInterest(publisherId, messageId));
-      nextRequest.handle(this::handleResponse);
+      currentRequest = client.getAsync(face, buildNextInterest(publisherId, messageId));
+      currentRequest.handle(this::handleResponse);
     }
 
     private Interest buildLatestInterest(long publisherId) {
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/PubSubNamespace.java b/src/main/java/com/intel/jndn/utils/pubsub/PubSubNamespace.java
index 89221cc..94da2db 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/PubSubNamespace.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/PubSubNamespace.java
@@ -35,15 +35,18 @@
   static final int MESSAGE_ATTRIBUTES_MARKER = 101;
   static final int MESSAGE_CONTENT_MARKER = 102;
 
-  static final Name DEFAULT_BROADCAST_PREFIX = new Name("/bcast");
+  static final Name DEFAULT_BROADCAST_PREFIX = new Name("/ndn/broadcast");
 
   private PubSubNamespace() {
     // do not instantiate this class
   }
 
+  static Name.Component toPublisherComponent(long publisherId) {
+    return Name.Component.fromNumberWithMarker(publisherId, PubSubNamespace.PUBLISHER_ID_MARKER);
+  }
+
   static Name toPublisherName(Name prefix, long publisherId) {
-    Name.Component publisherComponent = Name.Component.fromNumberWithMarker(publisherId, PubSubNamespace.PUBLISHER_ID_MARKER);
-    return new Name(prefix).append(publisherComponent);
+    return new Name(prefix).append(toPublisherComponent(publisherId));
   }
 
   static Name toAnnouncement(Name prefix, long publisherId, Announcement announcement) {
diff --git a/src/main/java/com/intel/jndn/utils/pubsub/Topic.java b/src/main/java/com/intel/jndn/utils/pubsub/Topic.java
index 5575712..b0b4ad4 100644
--- a/src/main/java/com/intel/jndn/utils/pubsub/Topic.java
+++ b/src/main/java/com/intel/jndn/utils/pubsub/Topic.java
@@ -21,7 +21,9 @@
 import com.intel.jndn.utils.impl.BoundedInMemoryPendingInterestTable;
 import net.named_data.jndn.Face;
 import net.named_data.jndn.Name;
+import net.named_data.jndn.util.Blob;
 
+import java.io.IOException;
 import java.util.Random;
 
 /**
@@ -39,12 +41,15 @@
   }
 
   // TODO move to PubSubFactory? change this to subscribe()
-  public Subscriber newSubscriber(Face face) {
-    return new NdnSubscriber(face, name, new NdnAnnouncementService(face, name), new AdvancedClient());
+  public Subscriber subscribe(Face face, On<Blob> onMessage, On<Exception> onError) throws RegistrationFailureException, IOException {
+    NdnSubscriber subscriber = new NdnSubscriber(face, name, onMessage, onError, new NdnAnnouncementService(face, name), new AdvancedClient());
+    subscriber.open();
+    return subscriber;
   }
 
   // TODO move to PubSubFactory? change this to publish()
   public Publisher newPublisher(Face face) {
-    return new NdnPublisher(face, name, new Random().nextLong(), new NdnAnnouncementService(face, name), new BoundedInMemoryPendingInterestTable(1024), new BoundedInMemoryContentStore(1024, 2000));
+    long publisherId = Math.abs(new Random().nextLong());
+    return new NdnPublisher(face, name, publisherId, new NdnAnnouncementService(face, name), new BoundedInMemoryPendingInterestTable(1024), new BoundedInMemoryContentStore(1024, 2000));
   }
 }
diff --git a/src/test/java/com/intel/jndn/utils/client/impl/BackoffRetryClientTest.java b/src/test/java/com/intel/jndn/utils/client/impl/BackoffRetryClientTest.java
new file mode 100644
index 0000000..f070911
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/client/impl/BackoffRetryClientTest.java
@@ -0,0 +1,65 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2016, 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 net.named_data.jndn.Face;
+import net.named_data.jndn.Interest;
+import net.named_data.jndn.Name;
+import net.named_data.jndn.OnTimeout;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static junit.framework.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Andrew Brown, andrew.brown@intel.com
+ */
+public class BackoffRetryClientTest {
+
+  private BackoffRetryClient instance;
+
+  @Before
+  public void before() {
+    instance = new BackoffRetryClient(10, 2);
+  }
+
+  @Test
+  public void retry() throws Exception {
+    Face face = mock(Face.class);
+    ArgumentCaptor<Interest> interestCaptor = ArgumentCaptor.forClass(Interest.class);
+    ArgumentCaptor<OnTimeout> onTimeoutCaptor = ArgumentCaptor.forClass(OnTimeout.class);
+    when(face.expressInterest(interestCaptor.capture(), any(), onTimeoutCaptor.capture())).then(new Answer<Long>() {
+      @Override
+      public Long answer(InvocationOnMock invocation) throws Throwable {
+        onTimeoutCaptor.getValue().onTimeout(interestCaptor.getValue());
+        return -1L;
+      }
+    });
+    Interest interest = new Interest(new Name("/backoff/test"), 1);
+    AtomicInteger timeouts = new AtomicInteger();
+
+    instance.retry(face, interest, null, interest1 -> timeouts.incrementAndGet());
+
+    assertEquals(1, timeouts.get());
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStoreTest.java b/src/test/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStoreTest.java
index aa896ba..49e3bc2 100644
--- a/src/test/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStoreTest.java
+++ b/src/test/java/com/intel/jndn/utils/impl/BoundedInMemoryContentStoreTest.java
@@ -16,9 +16,11 @@
 
 import com.intel.jndn.mock.MockFace;
 import com.intel.jndn.utils.ContentStore;
+import net.named_data.jndn.Interest;
 import net.named_data.jndn.Name;
 import net.named_data.jndn.util.Blob;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
@@ -39,9 +41,10 @@
     instance.put(new Name("/a"), new Blob("."));
 
     assertTrue(instance.has(new Name("/a")));
-    assertArrayEquals(".".getBytes(), instance.get(new Name("/a")).getImmutableArray());
+    assertArrayEquals(".".getBytes(), instance.get(new Name("/a")).get().getImmutableArray());
   }
 
+  @Ignore // TODO need bounds on NameTree
   @Test
   public void replacement() throws Exception {
     instance.put(new Name("/a"), new Blob("."));
@@ -79,4 +82,18 @@
     assertFalse(instance.has(new Name("/a")));
   }
 
+  @Test
+  public void retrieveWithSelectors() throws Exception {
+    instance.put(new Name("/a/1"), new Blob("."));
+    instance.put(new Name("/a/2"), new Blob(".."));
+    instance.put(new Name("/a/3"), new Blob("..."));
+
+    Interest interest1 = new Interest(new Name("/a")).setChildSelector(Interest.CHILD_SELECTOR_RIGHT);
+    assertTrue(instance.has(interest1));
+    assertEquals("...", instance.get(interest1).get().toString());
+
+    Interest interest2 = new Interest(new Name("/a")).setChildSelector(Interest.CHILD_SELECTOR_LEFT);
+    assertEquals(".", instance.get(interest2).get().toString());
+  }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/intel/jndn/utils/impl/DefaultNameTreeTest.java b/src/test/java/com/intel/jndn/utils/impl/DefaultNameTreeTest.java
new file mode 100644
index 0000000..0696c3c
--- /dev/null
+++ b/src/test/java/com/intel/jndn/utils/impl/DefaultNameTreeTest.java
@@ -0,0 +1,86 @@
+/*
+ * jndn-utils
+ * Copyright (c) 2016, 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.impl;
+
+import com.intel.jndn.utils.NameTree;
+import net.named_data.jndn.Name;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/**
+ * @author Andrew Brown, andrew.brown@intel.com
+ */
+public class DefaultNameTreeTest {
+
+  private NameTree<String> instance;
+
+  @Before
+  public void setUp() throws Exception {
+    instance = DefaultNameTree.newRootTree();
+    instance.insert(new Name("/a/b/c"), ".");
+    instance.insert(new Name("/a/b/d"), "..");
+    instance.insert(new Name("/a/e"), "...");
+  }
+
+  @Test
+  public void content() throws Exception {
+
+  }
+
+  @Test
+  public void name() throws Exception {
+
+  }
+
+  @Test
+  public void children() throws Exception {
+
+  }
+
+  @Test
+  public void parent() throws Exception {
+    assertNull(instance.parent());
+  }
+
+  @Test
+  public void find() throws Exception {
+    assertEquals(2, instance.find(new Name("/a/b")).get().children().size());
+  }
+
+  @Test
+  public void findDeep() throws Exception {
+    instance.insert(new Name("/a/e/x/y/z"), "...");
+    assertEquals(1, instance.find(new Name("/a/e/x")).get().children());
+  }
+
+  @Test
+  public void insert() throws Exception {
+
+  }
+
+  @Test
+  public void delete() throws Exception {
+
+  }
+
+  @Test
+  public void count() throws Exception {
+
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/intel/jndn/utils/pubsub/NdnSubscriberTest.java b/src/test/java/com/intel/jndn/utils/pubsub/NdnSubscriberTest.java
index b3ca959..7e7548e 100644
--- a/src/test/java/com/intel/jndn/utils/pubsub/NdnSubscriberTest.java
+++ b/src/test/java/com/intel/jndn/utils/pubsub/NdnSubscriberTest.java
@@ -40,7 +40,7 @@
     Face face = mock(Face.class);
     announcementService = mock(AnnouncementService.class);
     Client client = mock(Client.class);
-    instance = new NdnSubscriber(face, TOPIC_NAME, announcementService, client);
+    instance = new NdnSubscriber(face, TOPIC_NAME, null, null, announcementService, client);
   }
 
   @Test
diff --git a/src/test/java/com/intel/jndn/utils/pubsub/TopicTestIT.java b/src/test/java/com/intel/jndn/utils/pubsub/TopicTestIT.java
index 2b06e6d..f9279c9 100644
--- a/src/test/java/com/intel/jndn/utils/pubsub/TopicTestIT.java
+++ b/src/test/java/com/intel/jndn/utils/pubsub/TopicTestIT.java
@@ -26,6 +26,7 @@
 import net.named_data.jndn.util.Blob;
 import org.junit.Test;
 
+import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -48,15 +49,14 @@
     Topic topic = new Topic(new Name("/pub/sub/topic"));
     CountDownLatch latch = new CountDownLatch(3);
 
-    Subscriber subscriber = topic.newSubscriber(pubFace);
-    subscriber.subscribe(b -> latch.countDown(), e -> fail(e.getMessage()));
+    Subscriber subscriber = topic.subscribe(pubFace, b -> latch.countDown(), e -> fail(e.getMessage()));
 
     Publisher publisher = topic.newPublisher(subFace);
     publisher.publish(new Blob("."));
     publisher.publish(new Blob(".."));
     publisher.publish(new Blob("..."));
 
-    latch.await(2, TimeUnit.SECONDS);
+    latch.await(20, TimeUnit.MINUTES);
     assertEquals(0, latch.getCount());
   }
 
@@ -66,7 +66,7 @@
     AsyncTcpTransport.ConnectionInfo connectionInfo = new AsyncTcpTransport.ConnectionInfo(hostName, 6363, true);
     ThreadPoolFace face = new ThreadPoolFace(pool, transport, connectionInfo);
 
-    KeyChain keyChain = MockKeyChain.configure(new Name("/topic/test/it"));
+    KeyChain keyChain = MockKeyChain.configure(new Name("/topic/test/it").appendVersion(new Random().nextLong()));
     face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName());
 
     return face;