@BeforeClass
  public static void setUpBeforeClass() throws Exception {
    CCNTestBase.setUpBeforeClass();
    CCNTime version = new CCNTime();
    ContentName stringName = testHelper.getClassChildName(STRING_VALUE_NAME);
    for (int i = 0; i < data.length; ++i) {
      // save multiple versions of the same object.
      data[i] = new CCNStringObject(stringName, "Value " + i, SaveType.REPOSITORY, putHandle);
      Log.info(Log.FAC_TEST, "Saving as version " + version);
      data[i].save(version);
      version.increment(1); // avoid version collisions
    }

    gone =
        new CCNStringObject(
            testHelper.getClassChildName(GONE_VALUE_NAME),
            GONE_VALUE_NAME,
            SaveType.REPOSITORY,
            putHandle);
    gone.saveAsGone();
    TestUtils.checkObject(putHandle, gone);

    bigData = testHelper.getClassChildName(BIG_VALUE_NAME);

    bigDataContent = new byte[bigDataLength];
    Random rand = new Random();
    rand.nextBytes(bigDataContent);
    bigValueDigest = CCNDigestHelper.digest(bigDataContent);

    // generate some segmented data
    CCNRepositoryWriter writer = new CCNRepositoryWriter(putHandle);
    writer.newVersion(bigData, bigDataContent);
  }
  @Test
  public void testLinkToUnversioned() throws Exception {
    Log.info(Log.FAC_TEST, "Starting testLinkToUnversioned");

    // test dereferencing link to unversioned data.
    CCNRepositoryWriter writer = new CCNRepositoryWriter(putHandle);
    ContentName unversionedDataName =
        testHelper.getTestChildName("testLinkToUnversioned", "UnversionedBigData");
    // generate some segmented data; doesn't version the name
    writer.newVersion(unversionedDataName, bigDataContent);

    Link uvBigDataLink =
        new Link(
            unversionedDataName,
            "big",
            new LinkAuthenticator(new PublisherID(putHandle.keyManager().getDefaultKeyID())));
    ContentObject bigDataTarget =
        uvBigDataLink.dereference(SystemConfiguration.SETTABLE_SHORT_TIMEOUT, getHandle);
    Log.info(
        Log.FAC_TEST,
        "BigData: Dereferenced link "
            + uvBigDataLink
            + ", retrieved content "
            + ((null == bigDataTarget) ? "null" : bigDataTarget.name()));
    Assert.assertNotNull(bigDataTarget);
    Assert.assertTrue(uvBigDataLink.targetName().isPrefixOf(bigDataTarget.name()));
    Assert.assertTrue(SegmentationProfile.isFirstSegment(bigDataTarget.name()));

    Log.info(Log.FAC_TEST, "Completed testLinkToUnversioned");
  }
  @Test
  public void testMissingTarget() throws Exception {
    Log.info(Log.FAC_TEST, "Starting testMissingTarget");

    Link linkToNowhere =
        new Link(testHelper.getTestChildName("testMissingTarget", "linkToNowhere"));
    ContentObject nothing = linkToNowhere.dereference(SystemConfiguration.SHORT_TIMEOUT, getHandle);
    Assert.assertNull(nothing);

    Log.info(Log.FAC_TEST, "Completed testMissingTarget");
  }
  @BeforeClass
  public static void setUpBeforeClass() throws Exception {

    CCNTestHelper testHelper = new CCNTestHelper(GroupRecursiveKeyUpdateTestRepo.class);
    directoryBase = testHelper.getTestNamespace("testInOrder");
    userNamespace =
        GroupAccessControlProfile.userNamespaceName(UserConfiguration.defaultNamespace());
    groupNamespace =
        GroupAccessControlProfile.groupNamespaceName(UserConfiguration.defaultNamespace());
    userKeyStorePrefix = ContentName.fromNative(UserConfiguration.defaultNamespace(), "_keystore_");

    // create user identities with TestUserData
    td = new CreateUserData(userKeyStorePrefix, numberOfusers, true, "password".toCharArray());
    td.publishUserKeysToRepository(userNamespace);
    friendlyNames = td.friendlyNames().toArray(new String[0]);

    // create ACM
    handle = td.getHandleForUser(friendlyNames[1]);
    acm = new GroupAccessControlManager(directoryBase, groupNamespace, userNamespace, handle);
    acm.publishMyIdentity(
        ContentName.fromNative(userNamespace, friendlyNames[1]),
        handle.keyManager().getDefaultPublicKey());
  }
  @Before
  public void setUp() {
    try {

      names = new ArrayList<ContentName>();

      _putHandle = CCNHandle.open();
      _getHandle = CCNHandle.open();
      _fileHandle = CCNHandle.open();

      getne = new CCNNameEnumerator(_getHandle, this);

      putne = new CCNNameEnumerator(_putHandle, this);

      helper = new CCNTestHelper(this.getClass().getName());

      _prefix = helper.getClassNamespace();

      _class = ContentName.fromNative(_prefix, "classResponder");
      _class2 = ContentName.fromNative(_prefix, "classResponder2");
      _repo = ContentName.fromNative(_prefix, "repoResponder");

      updated = false;

      putne.registerNameSpace(_prefix);
      Log.info("registering namespace prefix: {0} count: {1}", _prefix, _prefix.count());

      putNERegisterName(_class);

      addContentToRepo(_repo);

    } catch (ConfigurationException e) {
      Assert.fail("Configuration Exception when setting up test. " + e.getMessage());
    } catch (IOException e) {
      Assert.fail("IOException when setting up test. " + e.getMessage());
    }
  }
  @Test
  public void testAutomatedDereferenceForGone() throws Exception {
    Log.info(Log.FAC_TEST, "Starting testAutomatedDereferenceForGone");

    Link versionedLink = new Link(gone.getVersionedName());
    LinkObject versionedLinkObject =
        new LinkObject(
            testHelper.getTestChildName("testAutomatedDereferenceForGone", "versionedLink"),
            versionedLink,
            SaveType.REPOSITORY,
            putHandle);
    versionedLinkObject.save();
    TestUtils.checkObject(putHandle, versionedLinkObject);

    Link unversionedLink = new Link(gone.getBaseName());
    LinkObject unversionedLinkObject =
        new LinkObject(
            testHelper.getTestChildName("testAutomatedDereferenceForGone", "unversionedLink"),
            unversionedLink,
            SaveType.REPOSITORY,
            putHandle);
    unversionedLinkObject.save();
    TestUtils.checkObject(putHandle, unversionedLinkObject);

    Link twoHopLink = new Link(unversionedLinkObject.getBaseName());
    LinkObject twoHopLinkObject =
        new LinkObject(
            testHelper.getTestChildName("testAutomatedDereferenceForGone", "twoHopLink"),
            twoHopLink,
            SaveType.REPOSITORY,
            putHandle);
    twoHopLinkObject.save();
    TestUtils.checkObject(putHandle, twoHopLinkObject);

    // read via the name iself
    CCNStringObject readObjectControl = new CCNStringObject(gone.getBaseName(), null);
    Assert.assertEquals(readObjectControl.getVersionedName(), gone.getVersionedName());
    Assert.assertTrue(readObjectControl.isGone());

    // read via the versioned link.
    CCNStringObject versionedReadObject =
        new CCNStringObject(versionedLinkObject.getBaseName(), getHandle);
    Assert.assertEquals(versionedReadObject.getVersionedName(), gone.getVersionedName());
    Assert.assertTrue(versionedReadObject.isGone());
    Assert.assertNotNull(versionedReadObject.getDereferencedLink());
    Assert.assertEquals(versionedReadObject.getDereferencedLink(), versionedLinkObject);

    // read latest version via the unversioned link
    CCNStringObject unversionedReadObject =
        new CCNStringObject(unversionedLinkObject.getBaseName(), getHandle);
    Assert.assertEquals(unversionedReadObject.getVersionedName(), gone.getVersionedName());
    Assert.assertTrue(unversionedReadObject.isGone());
    Assert.assertNotNull(unversionedReadObject.getDereferencedLink());
    Assert.assertEquals(unversionedReadObject.getDereferencedLink(), unversionedLinkObject);

    // read via the two-hop link
    CCNStringObject twoHopReadObject =
        new CCNStringObject(twoHopLinkObject.getBaseName(), getHandle);
    Assert.assertEquals(twoHopReadObject.getVersionedName(), gone.getVersionedName());
    Assert.assertTrue(twoHopReadObject.isGone());
    Assert.assertNotNull(twoHopReadObject.getDereferencedLink());
    Assert.assertEquals(twoHopReadObject.getDereferencedLink(), unversionedLinkObject);
    Assert.assertNotNull(twoHopReadObject.getDereferencedLink().getDereferencedLink());
    Assert.assertEquals(
        twoHopReadObject.getDereferencedLink().getDereferencedLink(), twoHopLinkObject);

    Log.info(Log.FAC_TEST, "Completed testAutomatedDereferenceForGone");
  }
  @Test
  public void testAutomatedDereferenceForStreams() throws Exception {
    Log.info(Log.FAC_TEST, "Starting testAutomatedDereferenceForStreams");

    Link bigDataLink =
        new Link(
            bigData,
            "big",
            new LinkAuthenticator(new PublisherID(putHandle.keyManager().getDefaultKeyID())));
    LinkObject bigDataLinkObject =
        new LinkObject(
            testHelper.getTestChildName("testAutomatedDereferenceForStreams", "bigDataLink"),
            bigDataLink,
            SaveType.REPOSITORY,
            putHandle);
    bigDataLinkObject.save();
    TestUtils.checkObject(putHandle, bigDataLinkObject);

    Link twoHopLink = new Link(bigDataLinkObject.getBaseName());
    LinkObject twoHopLinkObject =
        new LinkObject(
            testHelper.getTestChildName("testAutomatedDereferenceForStreams", "twoHopLink"),
            twoHopLink,
            SaveType.REPOSITORY,
            putHandle);
    twoHopLinkObject.save();
    TestUtils.checkObject(putHandle, twoHopLinkObject);

    CCNReader reader = new CCNReader(putHandle);
    byte[] bigDataReadback =
        reader.getVersionedData(
            bigDataLinkObject.getVersionedName(), null, SystemConfiguration.getDefaultTimeout());
    byte[] bdrdigest = CCNDigestHelper.digest(bigDataReadback);
    Log.info(
        Log.FAC_TEST,
        "Read back big data via link, got "
            + bigDataReadback.length
            + " bytes of an expected "
            + bigDataLength
            + ", digest match? "
            + (0 == DataUtils.compare(bdrdigest, bigValueDigest)));
    Assert.assertEquals(bigDataLength, bigDataReadback.length);
    Assert.assertArrayEquals(bdrdigest, bigValueDigest);

    byte[] bigDataReadback2 =
        reader.getVersionedData(
            twoHopLinkObject.getBaseName(), null, SystemConfiguration.getDefaultTimeout());
    byte[] bdr2digest = CCNDigestHelper.digest(bigDataReadback);
    Log.info(
        Log.FAC_TEST,
        "Read back big data via two links, got "
            + bigDataReadback2.length
            + " bytes of an expected "
            + bigDataLength
            + ", digest match? "
            + (0 == DataUtils.compare(bdr2digest, bigValueDigest)));
    Assert.assertEquals(bigDataLength, bigDataReadback2.length);
    Assert.assertArrayEquals(bdr2digest, bigValueDigest);

    Log.info(Log.FAC_TEST, "Completed testAutomatedDereferenceForStreams");
  }