diff --git a/BUCK b/BUCK
index 26aafae..17cda8a 100644
--- a/BUCK
+++ b/BUCK
@@ -18,7 +18,7 @@
   resources = glob(['src/main/resources/**/*']),
   manifest_entries = [
     'Implementation-Title: Ref Protection plugin',
-    'Implementation-URL: http://review-plus.sonyericsson.net/#/admin/projects/gerrit/plugins/ref-protection',
+    'Implementation-URL: http://gerrit.googlesource.com/plugins/ref-protection',
     'Gerrit-PluginName: ref-protection',
     'Gerrit-Module: com.googlesource.gerrit.plugins.refprotection.RefProtectionModule'
   ],
diff --git a/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupBranch.java b/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupBranch.java
deleted file mode 100644
index dbed47a..0000000
--- a/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupBranch.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- *  The MIT License
- *
- *  Copyright 2015 Sony Mobile Communications AB. All rights reserved.
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in
- *  all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- *  THE SOFTWARE.
- */
-package com.googlesource.gerrit.plugins.refprotection;
-
-import static org.eclipse.jgit.lib.Constants.R_HEADS;
-import static org.eclipse.jgit.lib.Constants.R_REFS;
-import static org.eclipse.jgit.lib.Constants.R_TAGS;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-
-public class BackupBranch {
-  public static final String R_BACKUPS = R_REFS + "backups/";
-
-  public static String get(String branchName) {
-    if (branchName.startsWith(R_HEADS) || branchName.startsWith(R_TAGS)) {
-      return String.format("%s-%s",
-          R_BACKUPS + branchName.replaceFirst(R_REFS, ""),
-          new SimpleDateFormat("YYYYMMdd-HHmmss").format(new Date()));
-    }
-
-    return branchName;
-  }
-}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupRef.java b/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupRef.java
new file mode 100644
index 0000000..af075c9
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/refprotection/BackupRef.java
@@ -0,0 +1,214 @@
+/*
+ *  The MIT License
+ *
+ *  Copyright 2015 Sony Mobile Communications AB. All rights reserved.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+package com.googlesource.gerrit.plugins.refprotection;
+
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.extensions.restapi.AuthException;
+import com.google.gerrit.extensions.restapi.BadRequestException;
+import com.google.gerrit.extensions.restapi.ResourceConflictException;
+import com.google.gerrit.server.config.PluginConfigFactory;
+import com.google.gerrit.server.events.RefUpdatedEvent;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.project.CreateBranch;
+import com.google.gerrit.server.project.ProjectResource;
+import com.google.inject.Inject;
+
+import org.eclipse.jgit.errors.IncorrectObjectTypeException;
+import org.eclipse.jgit.errors.MissingObjectException;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectInserter;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.TagBuilder;
+import org.eclipse.jgit.revwalk.RevTag;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.eclipse.jgit.lib.Constants.R_HEADS;
+import static org.eclipse.jgit.lib.Constants.R_REFS;
+import static org.eclipse.jgit.lib.Constants.R_TAGS;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class BackupRef {
+  public static final String R_BACKUPS = R_REFS + "backups/";
+  private static final Logger log =
+      LoggerFactory.getLogger(BackupRef.class);
+  private final CreateBranch.Factory createBranchFactory;
+  @Inject private static PluginConfigFactory cfg;
+  @Inject private static GitRepositoryManager repoManager;
+  @Inject @PluginName private static String pluginName;
+
+  @Inject
+  BackupRef(CreateBranch.Factory createBranchFactory) {
+    this.createBranchFactory = createBranchFactory;
+  }
+
+  public void createBackup(RefUpdatedEvent event, ProjectResource project) {
+    String refName = event.getRefName();
+
+    try (Repository git = repoManager.openRepository(project.getNameKey())) {
+      String backupRef = get(project, refName);
+
+      // No-op if the backup branch name is same as the original
+      if (backupRef.equals(refName)) {
+        return;
+      }
+
+      try (RevWalk revWalk = new RevWalk(git)) {
+        if (cfg.getFromGerritConfig(pluginName).getBoolean("createTag",
+            false)) {
+          TagBuilder tag = new TagBuilder();
+          tag.setTagger(
+              new PersonIdent(event.submitter.name, event.submitter.email));
+          tag.setObjectId(revWalk
+              .parseCommit(ObjectId.fromString(event.refUpdate.oldRev)));
+          String update = "Non-fast-forward update to";
+          if (event.refUpdate.newRev.equals(ObjectId.zeroId().getName())) {
+            update = "Deleted";
+          }
+          String type = "branch";
+          String fullMessage = "";
+          if (event.refUpdate.refName.startsWith(R_TAGS)) {
+            type = "tag";
+            try {
+              RevTag origTag =
+                  revWalk.parseTag(ObjectId.fromString(event.refUpdate.oldRev));
+              SimpleDateFormat format = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy ZZZZ");
+              PersonIdent taggerIdent = origTag.getTaggerIdent();
+              String tagger =
+                  String.format("Tagger: %s <%s>\nDate:   %s",
+                      taggerIdent.getName(), taggerIdent.getEmailAddress(),
+                      format.format(taggerIdent.getWhen()));
+              fullMessage = "\n\nOriginal tag:\n" + tagger + "\n\n" + origTag.getFullMessage();
+            } catch (MissingObjectException e) {
+              log.warn("Original tag does not exist", e);
+            } catch (IncorrectObjectTypeException e) {
+              log.warn("Original tag was not a tag", e);
+            } catch (IOException e) {
+              log.warn("Unable to read original tag details", e);
+            }
+          }
+          tag.setMessage(update + " " + type + " " + event.refUpdate.refName + fullMessage);
+          tag.setTag(backupRef);
+
+          ObjectInserter inserter = git.newObjectInserter();
+          ObjectId tagId = inserter.insert(tag);
+          inserter.flush();
+          RefUpdate tagRef = git.updateRef(tag.getTag());
+          tagRef.setNewObjectId(tagId);
+          tagRef.setRefLogMessage("tagged deleted branch/tag " + tag.getTag(),
+              false);
+          tagRef.setForceUpdate(false);
+          Result result = tagRef.update();
+          switch (result) {
+            case NEW:
+            case FORCED:
+              log.debug("Successfully created backup tag");
+              break;
+
+            case LOCK_FAILURE:
+              log.error("Failed to lock repository while creating backup tag");
+              break;
+
+            case REJECTED:
+              log.error("Tag already exists while creating backup tag");
+              break;
+
+            default:
+              log.error("Unknown error while creating backup tag");
+          }
+        } else {
+          CreateBranch.Input input = new CreateBranch.Input();
+          input.ref = backupRef;
+          // We need to parse the commit to ensure if it's a tag, we get the
+          // commit the tag points to!
+          input.revision = ObjectId.toString(
+              revWalk.parseCommit(ObjectId.fromString(event.refUpdate.oldRev))
+                  .getId());
+
+          try {
+            createBranchFactory.create(backupRef).apply(project, input);
+          } catch (BadRequestException | AuthException
+              | ResourceConflictException | IOException e) {
+            log.error(e.getMessage(), e);
+          }
+        }
+      }
+    } catch (RepositoryNotFoundException e) {
+      log.error("Repository does not exist", e);
+    } catch (IOException e) {
+      log.error("Could not open repository", e);
+    }
+  }
+
+  static String get(ProjectResource project, String refName) {
+    if (cfg.getFromGerritConfig(pluginName).getBoolean("useTimestamp", true)) {
+      return getTimestampBranch(refName);
+    }
+    else {
+      return getSequentialBranch(project, refName);
+    }
+  }
+
+  private static String getTimestampBranch(String refName) {
+    if (refName.startsWith(R_HEADS) || refName.startsWith(R_TAGS)) {
+      return String.format("%s-%s",
+          R_BACKUPS + refName.replaceFirst(R_REFS, ""),
+          new SimpleDateFormat("YYYYMMdd-HHmmss").format(new Date()));
+    }
+
+    return refName;
+  }
+
+  private static String getSequentialBranch(ProjectResource project, String branchName) {
+    Integer rev = 1;
+    String deletedName = branchName.replaceFirst(R_REFS, "");
+    try (Repository git = repoManager.openRepository(project.getNameKey())) {
+      for (Ref ref : git.getAllRefs().values()) {
+        String name = ref.getName();
+        if (name.startsWith(R_BACKUPS + deletedName + "/")) {
+          Integer thisNum =
+              Integer.parseInt(name.substring(name.lastIndexOf('/') + 1));
+          if (thisNum >= rev) {
+            rev = thisNum + 1;
+          }
+        }
+      }
+    } catch (RepositoryNotFoundException e) {
+      log.error("Repository does not exist", e);
+    } catch (IOException e) {
+      log.error("Could not determine latest revision of deleted branch", e);
+    }
+
+    return R_BACKUPS + deletedName + "/" + rev;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefProtectionModule.java b/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefProtectionModule.java
index 96d250c..b2700c7 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefProtectionModule.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefProtectionModule.java
@@ -23,14 +23,15 @@
  */
 package com.googlesource.gerrit.plugins.refprotection;
 
-import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
+import com.google.gerrit.common.EventListener;
 import com.google.gerrit.extensions.registration.DynamicSet;
 import com.google.inject.AbstractModule;
 
 public class RefProtectionModule extends AbstractModule {
   @Override
   protected void configure() {
-    DynamicSet.bind(binder(), GitReferenceUpdatedListener.class).to(
+    DynamicSet.bind(binder(), EventListener.class).to(
         RefUpdateListener.class);
+    requestStaticInjection(BackupRef.class);
   }
 }
diff --git a/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefUpdateListener.java b/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefUpdateListener.java
index 09d9c94..0ca08f4 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefUpdateListener.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/refprotection/RefUpdateListener.java
@@ -26,14 +26,14 @@
 import static org.eclipse.jgit.lib.Constants.R_HEADS;
 import static org.eclipse.jgit.lib.Constants.R_TAGS;
 
-import com.google.gerrit.extensions.events.GitReferenceUpdatedListener;
-import com.google.gerrit.extensions.restapi.AuthException;
-import com.google.gerrit.extensions.restapi.BadRequestException;
-import com.google.gerrit.extensions.restapi.ResourceConflictException;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gerrit.common.EventListener;
 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.server.CurrentUser;
+import com.google.gerrit.server.config.PluginConfigFactory;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.RefUpdatedEvent;
 import com.google.gerrit.server.git.GitRepositoryManager;
-import com.google.gerrit.server.project.CreateBranch;
 import com.google.gerrit.server.project.NoSuchProjectException;
 import com.google.gerrit.server.project.ProjectControl;
 import com.google.gerrit.server.project.ProjectResource;
@@ -49,75 +49,62 @@
 
 import java.io.IOException;
 
-class RefUpdateListener implements GitReferenceUpdatedListener {
+class RefUpdateListener implements EventListener {
 
   private static final Logger log =
       LoggerFactory.getLogger(RefUpdateListener.class);
-  private final CreateBranch.Factory createBranchFactory;
   private final ProjectControl.GenericFactory projectControl;
   private final CurrentUser user;
   private final GitRepositoryManager repoManager;
+  private final BackupRef backupRef;
+  private final boolean protectDeleted;
+  private final boolean protectFastForward;
 
   @Inject
-  RefUpdateListener(CreateBranch.Factory createBranchFactory,
-      ProjectControl.GenericFactory p,
+  RefUpdateListener(ProjectControl.GenericFactory p,
       CurrentUser user,
-      GitRepositoryManager repoManager) {
-    this.createBranchFactory = createBranchFactory;
+      GitRepositoryManager repoManager,
+      BackupRef backupRef,
+      PluginConfigFactory cfg,
+      @PluginName String pluginName) {
     this.projectControl = p;
     this.user = user;
     this.repoManager = repoManager;
+    this.backupRef = backupRef;
+    this.protectDeleted =
+        cfg.getFromGerritConfig(pluginName).getBoolean("protectDeleted", true);
+    this.protectFastForward =
+        cfg.getFromGerritConfig(pluginName).getBoolean("protectFastForward", true);
   }
 
   @Override
-  public void onGitReferenceUpdated(final Event event) {
-    if (isRelevantRef(event)) {
-      Project.NameKey nameKey = new Project.NameKey(event.getProjectName());
-      try {
-        ProjectResource project =
-            new ProjectResource(projectControl.controlFor(nameKey, user));
-        if (isRefDeleted(event) || isNonFastForwardUpdate(event, project)) {
-          createBackupBranch(event, project);
+  public void onEvent(Event event) {
+    if (event instanceof RefUpdatedEvent) {
+      RefUpdatedEvent refUpdate = (RefUpdatedEvent)event;
+      if ((protectDeleted || protectFastForward) && isRelevantRef(refUpdate)) {
+        Project.NameKey nameKey = refUpdate.getProjectNameKey();
+        try {
+          ProjectResource project =
+              new ProjectResource(projectControl.controlFor(nameKey, user));
+          if ((protectDeleted && isRefDeleted(refUpdate))
+              || (protectFastForward && isNonFastForwardUpdate(refUpdate,
+                  project))) {
+            backupRef.createBackup(refUpdate, project);
+          }
+        } catch (NoSuchProjectException | IOException e) {
+          log.error(e.getMessage(), e);
         }
-      } catch (NoSuchProjectException | IOException e) {
-        log.error(e.getMessage(), e);
       }
     }
   }
 
   /**
-   * Create a backup branch for the given ref.
-   *
-   * @param event the Event
-   */
-  private void createBackupBranch(Event event, ProjectResource project) {
-    String branchName = event.getRefName();
-    String backupRef = BackupBranch.get(branchName);
-
-    // No-op if the backup branch name is same as the original
-    if (backupRef.equals(branchName)) {
-      return;
-    }
-
-    CreateBranch.Input input = new CreateBranch.Input();
-    input.ref = backupRef;
-    input.revision = event.getOldObjectId();
-
-    try {
-      createBranchFactory.create(backupRef).apply(project, input);
-    } catch (BadRequestException | AuthException | ResourceConflictException
-        | IOException e) {
-      log.error(e.getMessage(), e);
-    }
-  }
-
-  /**
    * Is the event on a relevant ref?
    *
    * @param event the Event
    * @return True if relevant, otherwise False.
    */
-  private boolean isRelevantRef(Event event) {
+  private boolean isRelevantRef(RefUpdatedEvent event) {
     return (!isNewRef(event)) &&
            (event.getRefName().startsWith(R_HEADS)
             || event.getRefName().startsWith(R_TAGS));
@@ -129,8 +116,8 @@
    * @param event the Event
    * @return True if a new ref, otherwise False.
    */
-  private boolean isNewRef(Event event) {
-    return event.getOldObjectId().equals(ObjectId.zeroId().getName());
+  private boolean isNewRef(RefUpdatedEvent event) {
+    return event.refUpdate.oldRev.equals(ObjectId.zeroId().getName());
   }
 
   /**
@@ -139,11 +126,11 @@
    * @param event the Event
    * @return True if a ref deletion, otherwise False.
    */
-  private boolean isRefDeleted(Event event) {
-    if (event.getNewObjectId().equals(ObjectId.zeroId().getName())) {
+  private boolean isRefDeleted(RefUpdatedEvent event) {
+    if (event.refUpdate.newRev.equals(ObjectId.zeroId().getName())) {
       log.info(String.format(
           "Ref Deleted: project [%s] refname [%s] old object id [%s]",
-          event.getProjectName(), event.getRefName(), event.getOldObjectId()));
+          event.getProjectNameKey().toString(), event.getRefName(), event.refUpdate.oldRev));
       return true;
     }
     return false;
@@ -155,14 +142,19 @@
    * @param event the Event
    * @return True if a non-fast-forward update, otherwise False.
    */
-  private boolean isNonFastForwardUpdate(Event event, ProjectResource project)
+  private boolean isNonFastForwardUpdate(RefUpdatedEvent event, ProjectResource project)
       throws RepositoryNotFoundException, IOException {
+    if (isRefDeleted(event)) {
+      // Can't be non-fast-forward if the ref was deleted, and
+      // attempting a check would cause a MissingObjectException.
+      return false;
+    }
     try (Repository repo = repoManager.openRepository(project.getNameKey())) {
       try (RevWalk walk = new RevWalk(repo)) {
         RevCommit oldCommit =
-            walk.parseCommit(repo.resolve(event.getOldObjectId()));
+            walk.parseCommit(repo.resolve(event.refUpdate.oldRev));
         RevCommit newCommit =
-            walk.parseCommit(repo.resolve(event.getNewObjectId()));
+            walk.parseCommit(repo.resolve(event.refUpdate.newRev));
         return !walk.isMergedInto(oldCommit, newCommit);
       }
     }
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
index c681000..4d2d541 100644
--- a/src/main/resources/Documentation/about.md
+++ b/src/main/resources/Documentation/about.md
@@ -1,10 +1,24 @@
 Ref protection plugin.
 
-Protects against commits being lost by creating backups of deleted refs under
-the `refs/backups/` namespace.
+Protects against commits being lost by creating backups of deleted refs 
+(or non-fast-forward commits) under the `refs/backups/` namespace.
+
+Branch deletion protection can be disabled by setting 
+`plugin.ref-protection.protectDeleted false` in `gerrit.config`.
+Similarly, non-fast-forward update protection can be disabled with
+`plugin.ref-protection.protectFastForward false`.
 
 Branches under `refs/heads/` that are deleted or rewritten are backed up
-as `refs/backups/heads/branch-name-YYYYMMDD-HHmmss`.
+as `refs/backups/heads/branch-name-YYYYMMDD-HHmmss` by default, or as
+sequentially increasing numbers under `refs/backups/heads/branch-name/#`
+by setting `plugin.ref-protection.useTimestamp false`.
 
 Tags under `refs/tags/` that are deleted are backed up (as branches) as
-`refs/backups/tags/tag-name-YYYYMMDD-HHmmss`.
+`refs/backups/tags/tag-name-YYYYMMDD-HHmmss` or as sequentially
+increasing numbers under `refs/backups/tags/branch-name/#` using the same
+`plugin.ref-protection.useTimestamp` setting.
+
+By default, the backups are created as branches.  Optionally, they may
+be created as tags, containing information about the original ref that
+was changed, as well as the user that performed the change.  This can
+be enabled by setting `plugin.ref-protection.createTag true`.
diff --git a/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupBranchNameTest.java b/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupBranchNameTest.java
deleted file mode 100644
index b2bc9a2..0000000
--- a/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupBranchNameTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package com.googlesource.gerrit.plugins.refprotection;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import org.junit.Test;
-
-public class BackupBranchNameTest {
-
-  @Test
-  public void backupBranchNameForTag() throws Exception {
-    String name = BackupBranch.get("refs/tags/v1.0");
-    String expected_prefix = BackupBranch.R_BACKUPS + "tags/v1.0-";
-    assertThat(name).startsWith(expected_prefix);
-  }
-
-  @Test
-  public void backupBranchNameForBranch() throws Exception {
-    String name = BackupBranch.get("refs/heads/master");
-    String expected_prefix = BackupBranch.R_BACKUPS + "heads/master-";
-    assertThat(name).startsWith(expected_prefix);
-  }
-
-  @Test
-  public void backupBranchNameForUnsupportedNamespace() throws Exception {
-    String ref = "refs/changes/45/12345/1";
-    assertThat(BackupBranch.get(ref)).isEqualTo(ref);
-  }
-}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupRefNameTest.java b/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupRefNameTest.java
new file mode 100644
index 0000000..d38f3b5
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/refprotection/BackupRefNameTest.java
@@ -0,0 +1,28 @@
+package com.googlesource.gerrit.plugins.refprotection;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+
+public class BackupRefNameTest {
+
+  @Test
+  public void backupTimestampRefNameForTag() throws Exception {
+    String name = BackupRef.get(null, "refs/tags/v1.0");
+    String expected_prefix = BackupRef.R_BACKUPS + "tags/v1.0-";
+    assertThat(name).startsWith(expected_prefix);
+  }
+
+  @Test
+  public void backupTimestampRefNameForBranch() throws Exception {
+    String name = BackupRef.get(null, "refs/heads/master");
+    String expected_prefix = BackupRef.R_BACKUPS + "heads/master-";
+    assertThat(name).startsWith(expected_prefix);
+  }
+
+  @Test
+  public void backupTimestampRefNameForUnsupportedNamespace() throws Exception {
+    String ref = "refs/changes/45/12345/1";
+    assertThat(BackupRef.get(null, ref)).isEqualTo(ref);
+  }
+}