[tor-commits] [metrics-lib/master] Make votes use the general network-status parsing code.

15 Dec 2011

commit cb9c62a90e30052db5599bc469da95de161af087
Author: Karsten Loesing <karsten.loesing@gmx.net>
Date:   Thu Dec 15 20:45:42 2011 +0100

    Make votes use the general network-status parsing code.
---
 .../descriptor/RelayNetworkStatusVote.java         |   11 +-
 .../descriptor/impl/NetworkStatusImpl.java         |   20 +-
 .../impl/RelayNetworkStatusVoteImpl.java           |  577 ++++++++++++--------
 .../impl/RelayNetworkStatusVoteImplTest.java       |  574 +++++++++++++++++++
 4 files changed, 933 insertions(+), 249 deletions(-)

diff --git a/src/org/torproject/descriptor/RelayNetworkStatusVote.java b/src/org/torproject/descriptor/RelayNetworkStatusVote.java
index 6bfdd6f..aab90bd 100644
--- a/src/org/torproject/descriptor/RelayNetworkStatusVote.java
+++ b/src/org/torproject/descriptor/RelayNetworkStatusVote.java
@@ -27,8 +27,11 @@ public interface RelayNetworkStatusVote extends Descriptor {
   /* Return the valid-until time in milliseconds. */
   public long getValidUntilMillis();
 
-  /* Return a list of the voting-delay times in seconds. */
-  public List<Long> getVotingDelay();
+  /* Return the VoteSeconds time in seconds. */
+  public long getVoteSeconds();
+
+  /* Return the DistSeconds time in seconds. */
+  public long getDistSeconds();
 
   /* Return recommended server versions or null if the authority doesn't
    * recommend server versions. */
@@ -65,6 +68,10 @@ public interface RelayNetworkStatusVote extends Descriptor {
   /* Return the directory key certificate version. */
   public int getDirKeyCertificateVersion();
 
+  /* Return the legacy key or null if the directory authority does not use
+   * a legacy key. */
+  public String getLegacyKey();
+
   /* Return the directory key publication timestamp. */
   public long getDirKeyPublishedMillis();
 
diff --git a/src/org/torproject/descriptor/impl/NetworkStatusImpl.java b/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
index 6ca546e..af8b9e2 100644
--- a/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
+++ b/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
@@ -51,6 +51,7 @@ public abstract class NetworkStatusImpl {
   protected NetworkStatusImpl(byte[] rawDescriptorBytes)
       throws DescriptorParseException {
     this.rawDescriptorBytes = rawDescriptorBytes;
+    this.countKeywords(rawDescriptorBytes);
     this.splitAndParseParts(rawDescriptorBytes);
   }
 
@@ -126,7 +127,6 @@ public abstract class NetworkStatusImpl {
     System.arraycopy(this.rawDescriptorBytes, start,
         headerBytes, 0, end - start);
     this.rememberFirstKeyword(headerBytes);
-    this.countKeywords(headerBytes);
     this.parseHeader(headerBytes);
   }
 
@@ -153,7 +153,6 @@ public abstract class NetworkStatusImpl {
     byte[] directoryFooterBytes = new byte[end - start];
     System.arraycopy(this.rawDescriptorBytes, start,
         directoryFooterBytes, 0, end - start);
-    this.countKeywords(directoryFooterBytes);
     this.parseFooter(directoryFooterBytes);
   }
 
@@ -264,17 +263,17 @@ public abstract class NetworkStatusImpl {
    * subclasses. */
   private Map<String, Integer> parsedKeywords =
       new HashMap<String, Integer>();
-  protected void countKeywords(byte[] headerOrFooterBytes)
+  protected void countKeywords(byte[] rawDescriptorBytes)
       throws DescriptorParseException {
     try {
       BufferedReader br = new BufferedReader(new StringReader(
-          new String(headerOrFooterBytes)));
+          new String(rawDescriptorBytes)));
       String line;
       boolean skipCrypto = false;
       while ((line = br.readLine()) != null) {
         if (line.startsWith("-----BEGIN")) {
           skipCrypto = true;
-        } else if (line.equals("-----END")) {
+        } else if (line.startsWith("-----END")) {
           skipCrypto = false;
         } else if (!skipCrypto) {
           String keyword = line.split(" ", -1)[0];
@@ -299,11 +298,14 @@ public abstract class NetworkStatusImpl {
   protected void checkExactlyOnceKeywords(Set<String> keywords)
       throws DescriptorParseException {
     for (String keyword : keywords) {
-      if (!this.parsedKeywords.containsKey(keyword) ||
-          this.parsedKeywords.get(keyword) != 1) {
+      int contained = 0;
+      if (this.parsedKeywords.containsKey(keyword)) {
+        contained = this.parsedKeywords.get(keyword);
+      }
+      if (contained != 1) {
         throw new DescriptorParseException("Keyword '" + keyword + "' is "
-            + "contained " + this.parsedKeywords.get(keyword) + " times, "
-            + "but must be contained exactly once.");
+            + "contained " + contained + " times, but must be contained "
+            + "exactly once.");
       }
     }
   }
diff --git a/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java b/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
index a7a5328..5089210 100644
--- a/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
+++ b/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
@@ -7,258 +7,341 @@ import java.io.IOException;
 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.SortedMap;
 import java.util.SortedSet;
-import java.util.TimeZone;
 import java.util.TreeMap;
 import java.util.TreeSet;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import org.torproject.descriptor.Descriptor;
-import org.torproject.descriptor.NetworkStatusEntry;
 import org.torproject.descriptor.RelayNetworkStatusVote;
 
+/* TODO Find out if all keywords in the dir-source section are required.
+ * They are not all mentioned in dir-spec.txt. */
+
 /* Contains a network status vote. */
-/* TODO This class is sharing a lot of parsing code with the consensus
- * class.  Should there be an abstract super class for the two? */
-public class RelayNetworkStatusVoteImpl
+public class RelayNetworkStatusVoteImpl extends NetworkStatusImpl
     implements RelayNetworkStatusVote {
 
   protected static List<RelayNetworkStatusVote> parseVotes(
-      byte[] voteBytes) {
+      byte[] votesBytes) {
     List<RelayNetworkStatusVote> parsedVotes =
         new ArrayList<RelayNetworkStatusVote>();
-    String startToken = "network-status-version 3";
-    String splitToken = "\n" + startToken;
-    String ascii = new String(voteBytes);
-    int length = voteBytes.length, start = ascii.indexOf(startToken);
-    while (start < length) {
-      int end = ascii.indexOf(splitToken, start);
-      if (end < 0) {
-        end = length;
-      } else {
-        end += 1;
+    List<byte[]> splitVotesBytes =
+        NetworkStatusImpl.splitRawDescriptorBytes(votesBytes,
+        "network-status-version 3");
+    try {
+      for (byte[] voteBytes : splitVotesBytes) {
+        RelayNetworkStatusVote parsedVote =
+            new RelayNetworkStatusVoteImpl(voteBytes);
+        parsedVotes.add(parsedVote);
       }
-      byte[] descBytes = new byte[end - start];
-      System.arraycopy(voteBytes, start, descBytes, 0, end - start);
-      RelayNetworkStatusVote parsedVote =
-          new RelayNetworkStatusVoteImpl(descBytes);
-      parsedVotes.add(parsedVote);
-      start = end;
+    } catch (DescriptorParseException e) {
+      /* TODO Handle this error somehow. */
+      System.err.println("Failed to parse vote.  Skipping.");
+      e.printStackTrace();
     }
     return parsedVotes;
   }
 
-  protected RelayNetworkStatusVoteImpl(byte[] voteBytes) {
-    this.voteBytes = voteBytes;
-    this.parseVoteBytes();
-    this.checkConsistency();
-    /* TODO Find a way to handle parse and consistency-check problems. */
+  protected RelayNetworkStatusVoteImpl(byte[] voteBytes)
+      throws DescriptorParseException {
+    super(voteBytes);
+    Set<String> exactlyOnceKeywords = new HashSet<String>(Arrays.asList((
+        "vote-status,consensus-methods,published,valid-after,fresh-until,"
+        + "valid-until,voting-delay,known-flags,dir-source,"
+        + "dir-key-certificate-version,fingerprint,dir-key-published,"
+        + "dir-key-expires,directory-footer").split(",")));
+    this.checkExactlyOnceKeywords(exactlyOnceKeywords);
+    Set<String> atMostOnceKeywords = new HashSet<String>(Arrays.asList((
+        "client-versions,server-versions,params,contact,legacy-key").
+        split(",")));
+    this.checkAtMostOnceKeywords(atMostOnceKeywords);
+    this.checkFirstKeyword("network-status-version");
   }
 
-  private void parseVoteBytes() {
-    String line = null;
+  protected void parseHeader(byte[] headerBytes)
+      throws DescriptorParseException {
     try {
       BufferedReader br = new BufferedReader(new StringReader(
-          new String(this.voteBytes)));
-      SimpleDateFormat dateTimeFormat = new SimpleDateFormat(
-          "yyyy-MM-dd HH:mm:ss");
-      dateTimeFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
-      StringBuilder dirSourceEntryLines = null, statusEntryLines = null;
-      boolean skipCrypto = false;
+          new String(headerBytes)));
+      String line;
       while ((line = br.readLine()) != null) {
-        if (line.startsWith("network-status-version ")) {
-          this.networkStatusVersion = Integer.parseInt(line.substring(
-              "network-status-version ".length()));
-        } else if (line.startsWith("vote-status ")) {
-          if (!line.equals("vote-status vote")) {
-            throw new RuntimeException("Line '" + line + "' indicates "
-                + "that this string is not a vote.  Aborting parsing.");
-          }
-        } else if (line.startsWith("consensus-methods ")) {
-          for (String consensusMethodString : line.substring(
-              "consensus-methods ".length()).split(" ")) {
-            this.consensusMethods.add(Integer.parseInt(
-            consensusMethodString));
-          }
-        } else if (line.startsWith("published ")) {
-          this.publishedMillis = dateTimeFormat.parse(
-              line.substring("published ".length())).getTime();
-        } else if (line.startsWith("valid-after ")) {
-          this.validAfterMillis = dateTimeFormat.parse(
-              line.substring("valid-after ".length())).getTime();
-        } else if (line.startsWith("fresh-until ")) {
-          this.freshUntilMillis = dateTimeFormat.parse(
-              line.substring("fresh-until ".length())).getTime();
-        } else if (line.startsWith("valid-until ")) {
-          this.validUntilMillis = dateTimeFormat.parse(
-              line.substring("valid-until ".length())).getTime();
-        } else if (line.startsWith("voting-delay ")) {
-          for (String votingDelayString : line.substring(
-              "voting-delay ".length()).split(" ")) {
-            this.votingDelay.add(Long.parseLong(votingDelayString));
-          }
-        } else if (line.startsWith("client-versions ")) {
-          this.recommendedClientVersions =
-              Arrays.asList(line.split(" ")[1].split(","));
-        } else if (line.startsWith("server-versions ")) {
-          this.recommendedServerVersions =
-              Arrays.asList(line.split(" ")[1].split(","));
-        } else if (line.startsWith("known-flags ")) {
-          for (String flag : line.substring("known-flags ".length()).
-              split(" ")) {
-            this.knownFlags.add(flag);
-          }
-        } else if (line.startsWith("params ")) {
-          if (line.length() > "params ".length()) {
-            for (String param :
-                line.substring("params ".length()).split(" ")) {
-              String paramName = param.split("=")[0];
-              int paramValue = Integer.parseInt(param.split("=")[1]);
-              this.consensusParams.put(paramName, paramValue);
-            }
-          }
-        } else if (line.startsWith("dir-source ")) {
-          String[] parts = line.split(" ");
-          this.nickname = parts[1];
-          this.identity = parts[2];
-          this.address = parts[4];
-          this.dirPort = Integer.parseInt(parts[5]);
-          this.orPort = Integer.parseInt(parts[6]);
-          /* TODO Add code for parsing legacy dir sources. */
-        } else if (line.startsWith("contact ")) {
-          this.contactLine = line.substring("contact ".length());
-        } else if (line.startsWith("dir-key-certificate-version ")) {
-          this.dirKeyCertificateVersion = Integer.parseInt(line.substring(
-              "dir-key-certificate-version ".length()));
-        } else if (line.startsWith("fingerprint ")) {
-          /* Nothing new to learn here.  We already know the fingerprint
-           * from the dir-source line. */
-        } else if (line.startsWith("dir-key-published ")) {
-          this.dirKeyPublishedMillis = dateTimeFormat.parse(
-              line.substring("dir-key-published ".length())).getTime();
-        } else if (line.startsWith("dir-key-expires ")) {
-          this.dirKeyExpiresMillis = dateTimeFormat.parse(
-              line.substring("dir-key-expires ".length())).getTime();
-        } else if (line.equals("dir-identity-key") ||
-            line.equals("dir-signing-key") ||
-            line.equals("dir-key-crosscert") ||
-            line.equals("dir-key-certification")) {
-          /* Ignore crypto parts for now. */
-        } else if (line.startsWith("r ") ||
-            line.equals("directory-footer")) {
-          if (statusEntryLines != null) {
-            try {
-              NetworkStatusEntryImpl statusEntry =
-                  new NetworkStatusEntryImpl(
-                  statusEntryLines.toString().getBytes());
-              this.statusEntries.put(statusEntry.getFingerprint(),
-                  statusEntry);
-            } catch (DescriptorParseException e) {
-              System.err.println("Could not parse status entry in vote.  "
-                  + "Skipping.");
-            }
-            statusEntryLines = null;
-          }
-          if (line.startsWith("r ")) {
-            statusEntryLines = new StringBuilder();
-            statusEntryLines.append(line + "\n");
-          }
-        } else if (line.startsWith("s ") || line.equals("s") ||
-            line.startsWith("opt v ") || line.startsWith("w ") ||
-            line.startsWith("p ") || line.startsWith("m ")) {
-          statusEntryLines.append(line + "\n");
-        } else if (line.startsWith("directory-signature ")) {
-          String[] parts = line.split(" ");
-          String identity = parts[1];
-          String signingKeyDigest = parts[2];
-          this.directorySignatures.put(identity, signingKeyDigest);
-        } else if (line.startsWith("-----BEGIN")) {
-          skipCrypto = true;
-        } else if (line.startsWith("-----END")) {
-          skipCrypto = false;
-        } else if (!skipCrypto) {
-          throw new RuntimeException("Unrecognized line '" + line + "'.");
+        String[] parts = line.split(" ");
+        String keyword = parts[0];
+        if (keyword.equals("network-status-version")) {
+          this.parseNetworkStatusVersionLine(line, parts);
+        } else if (keyword.equals("vote-status")) {
+          this.parseVoteStatusLine(line, parts);
+        } else if (keyword.equals("consensus-methods")) {
+          this.parseConsensusMethodsLine(line, parts);
+        } else if (keyword.equals("published")) {
+          this.parsePublishedLine(line, parts);
+        } else if (keyword.equals("valid-after")) {
+          this.parseValidAfterLine(line, parts);
+        } else if (keyword.equals("fresh-until")) {
+          this.parseFreshUntilLine(line, parts);
+        } else if (keyword.equals("valid-until")) {
+          this.parseValidUntilLine(line, parts);
+        } else if (keyword.equals("voting-delay")) {
+          this.parseVotingDelayLine(line, parts);
+        } else if (keyword.equals("client-versions")) {
+          this.parseClientVersionsLine(line, parts);
+        } else if (keyword.equals("server-versions")) {
+          this.parseServerVersionsLine(line, parts);
+        } else if (keyword.equals("known-flags")) {
+          this.parseKnownFlagsLine(line, parts);
+        } else if (keyword.equals("params")) {
+          this.parseParamsLine(line, parts);
+        } else {
+          /* TODO Is throwing an exception the right thing to do here?
+           * This is probably fine for development, but once the library
+           * is in production use, this seems annoying. */
+          throw new DescriptorParseException("Unrecognized line '" + line
+              + "'.");
         }
       }
     } catch (IOException e) {
       throw new RuntimeException("Internal error: Ran into an "
           + "IOException while parsing a String in memory.  Something's "
           + "really wrong.", e);
-    } catch (ParseException e) {
-      /* TODO Handle me correctly. */
-      throw new RuntimeException("Parse error in line '" + line + "'.");
+    }
+  }
+
+  private void parseNetworkStatusVersionLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (!line.equals("network-status-version 3")) {
+      throw new DescriptorParseException("Illegal network status version "
+          + "number in line '" + line + "'.");
+    }
+    this.networkStatusVersion = 3;
+  }
+
+  private void parseVoteStatusLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 2 || !parts[1].equals("vote")) {
+      throw new DescriptorParseException("Line '" + line + "' indicates "
+          + "that this is not a vote.");
+    }
+  }
+
+  private void parseConsensusMethodsLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length < 2) {
+      throw new DescriptorParseException("Illegal line '" + line
+          + "' in vote.");
+    }
+    this.consensusMethods = new ArrayList<Integer>();
+    for (int i = 1; i < parts.length; i++) {
+      int consensusMethod = -1;
+      try {
+        consensusMethod = Integer.parseInt(parts[i]);
+      } catch (NumberFormatException e) {
+        /* We'll notice below that consensusMethod is still -1. */
+      }
+      if (consensusMethod < 1) {
+        throw new DescriptorParseException("Illegal consensus method "
+            + "number in line '" + line + "'.");
+      }
+      this.consensusMethods.add(Integer.parseInt(parts[i]));
+    }
+  }
+
+  private void parsePublishedLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.publishedMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseValidAfterLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.validAfterMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseFreshUntilLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.freshUntilMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseValidUntilLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.validUntilMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseVotingDelayLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 3) {
+      throw new DescriptorParseException("Wrong number of values in line "
+          + "'" + line + "'.");
+    }
+    try {
+      this.voteSeconds = Long.parseLong(parts[1]);
+      this.distSeconds = Long.parseLong(parts[2]);
     } catch (NumberFormatException e) {
-      /* TODO Handle me.  In theory, we shouldn't catch runtime
-       * exceptions, but in this case it keeps the parsing code small. */
-    } catch (ArrayIndexOutOfBoundsException e) {
-      /* TODO Handle me.  In theory, we shouldn't catch runtime
-       * exceptions, but in this case it keeps the parsing code small. */
+      throw new DescriptorParseException("Illegal values in line '" + line
+          + "'.");
     }
   }
 
-  private byte[] voteBytes;
-  public byte[] getRawDescriptorBytes() {
-    return this.voteBytes;
+  private void parseClientVersionsLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.recommendedClientVersions = this.parseClientOrServerVersions(
+        line, parts);
   }
 
-  private int networkStatusVersion;
-  public int getNetworkStatusVersion() {
-    return this.networkStatusVersion;
+  private void parseServerVersionsLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.recommendedServerVersions = this.parseClientOrServerVersions(
+        line, parts);
   }
 
-  private List<Integer> consensusMethods = new ArrayList<Integer>();
-  public List<Integer> getConsensusMethods() {
-    return this.consensusMethods;
+  private List<String> parseClientOrServerVersions(String line,
+      String[] parts) throws DescriptorParseException {
+    List<String> result = new ArrayList<String>();
+    if (parts.length == 1) {
+      return result;
+    } else if (parts.length > 2) {
+      throw new DescriptorParseException("Illegal versions line '" + line
+          + "'.");
+    }
+    String[] versions = parts[1].split(",", -1);
+    for (int i = 0; i < versions.length; i++) {
+      String version = versions[i];
+      if (version.length() < 1) {
+        throw new DescriptorParseException("Illegal versions line '"
+            + line + "'.");
+      }
+      result.add(version);
+    }
+    return result;
   }
 
-  private long publishedMillis;
-  public long getPublishedMillis() {
-    return this.publishedMillis;
+  private void parseKnownFlagsLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length < 2) {
+      throw new DescriptorParseException("No known flags in line '" + line
+          + "'.");
+    }
+    this.knownFlags = new TreeSet<String>();
+    for (int i = 1; i < parts.length; i++) {
+      this.knownFlags.add(parts[i]);
+    }
   }
 
-  private long validAfterMillis;
-  public long getValidAfterMillis() {
-    return this.validAfterMillis;
+  private void parseParamsLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.consensusParams = ParseHelper.parseKeyValuePairs(line, parts, 1);
   }
 
-  private long freshUntilMillis;
-  public long getFreshUntilMillis() {
-    return this.freshUntilMillis;
+  protected void parseDirSource(byte[] dirSourceBytes)
+      throws DescriptorParseException {
+    try {
+      BufferedReader br = new BufferedReader(new StringReader(
+          new String(dirSourceBytes)));
+      String line;
+      boolean skipCrypto = false;
+      while ((line = br.readLine()) != null) {
+        String[] parts = line.split(" ");
+        String keyword = parts[0];
+        if (keyword.equals("dir-source")) {
+          this.parseDirSourceLine(line, parts);
+        } else if (keyword.equals("contact")) {
+          this.parseContactLine(line, parts);
+        } else if (keyword.equals("dir-key-certificate-version")) {
+          this.parseDirKeyCertificateVersionLine(line, parts);
+        } else if (keyword.equals("fingerprint")) {
+          /* Nothing new to learn here.  We already know the fingerprint
+           * from the dir-source line. */
+        } else if (keyword.equals("legacy-key")) {
+          this.parseLegacyKeyLine(line, parts);
+        } else if (keyword.equals("dir-key-published")) {
+          this.parseDirKeyPublished(line, parts);
+        } else if (keyword.equals("dir-key-expires")) {
+          this.parseDirKeyExpiresLine(line, parts);
+        } else if (keyword.equals("dir-identity-key") ||
+            keyword.equals("dir-signing-key") ||
+            keyword.equals("dir-key-crosscert") ||
+            keyword.equals("dir-key-certification")) {
+        } else if (line.startsWith("-----BEGIN")) {
+          skipCrypto = true;
+        } else if (line.equals("-----END")) {
+          skipCrypto = false;
+        } else if (!skipCrypto) {
+          /* TODO Is throwing an exception the right thing to do here?
+           * This is probably fine for development, but once the library
+           * is in production use, this seems annoying. */
+          throw new DescriptorParseException("Unrecognized line '" + line
+              + "'.");
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException("Internal error: Ran into an "
+          + "IOException while parsing a String in memory.  Something's "
+          + "really wrong.", e);
+    }
   }
 
-  private long validUntilMillis;
-  public long getValidUntilMillis() {
-    return this.validUntilMillis;
+  private void parseDirSourceLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.nickname = ParseHelper.parseNickname(line, parts[1]);
+    this.identity = ParseHelper.parseTwentyByteHexString(line, parts[2]);
+    this.address = ParseHelper.parseIpv4Address(line, parts[4]);
+    this.dirPort = ParseHelper.parsePort(line, parts[5]);
+    this.orPort = ParseHelper.parsePort(line, parts[6]);
   }
 
-  private List<Long> votingDelay = new ArrayList<Long>();
-  public List<Long> getVotingDelay() {
-    return new ArrayList<Long>(this.votingDelay);
+  private void parseContactLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (line.length() > "contact ".length()) {
+      this.contactLine = line.substring("contact ".length());
+    } else {
+      this.contactLine = "";
+    }
   }
 
-  private List<String> recommendedClientVersions;
-  public List<String> getRecommendedClientVersions() {
-    return this.recommendedClientVersions == null ? null :
-        new ArrayList<String>(this.recommendedClientVersions);
+  private void parseDirKeyCertificateVersionLine(String line,
+      String[] parts) throws DescriptorParseException {
+    if (parts.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line
+          + "' in vote.");
+    }
+    try {
+      this.dirKeyCertificateVersion = Integer.parseInt(parts[1]);
+    } catch (NumberFormatException e) {
+      throw new DescriptorParseException("Illegal dir key certificate "
+          + "version in line '" + line + "'.");
+    }
+    if (this.dirKeyCertificateVersion < 1) {
+      throw new DescriptorParseException("Illegal dir key certificate "
+          + "version in line '" + line + "'.");
+    }
   }
 
-  private List<String> recommendedServerVersions;
-  public List<String> getRecommendedServerVersions() {
-    return this.recommendedServerVersions == null ? null :
-        new ArrayList<String>(this.recommendedServerVersions);
+  private void parseLegacyKeyLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    this.legacyKey = ParseHelper.parseTwentyByteHexString(line, parts[2]);
   }
 
-  private SortedSet<String> knownFlags = new TreeSet<String>();
-  public SortedSet<String> getKnownFlags() {
-    return new TreeSet<String>(this.knownFlags);
+  private void parseDirKeyPublished(String line, String[] parts)
+      throws DescriptorParseException {
+    this.dirKeyPublishedMillis = ParseHelper.parseTimestampAtIndex(line,
+        parts, 1, 2);
   }
 
-  private SortedMap<String, Integer> consensusParams =
-      new TreeMap<String, Integer>();
-  public SortedMap<String, Integer> getConsensusParams() {
-    return new TreeMap<String, Integer>(this.consensusParams);
+  private void parseDirKeyExpiresLine(String line, String[] parts)
+      throws DescriptorParseException {
+    this.dirKeyExpiresMillis = ParseHelper.parseTimestampAtIndex(line,
+        parts, 1, 2);
+  }
+
+  protected void parseFooter(byte[] footerBytes) {
+    /* There is nothing in the footer that we'd want to parse. */
   }
 
   private String nickname;
@@ -296,6 +379,11 @@ public class RelayNetworkStatusVoteImpl
     return this.dirKeyCertificateVersion;
   }
 
+  private String legacyKey;
+  public String getLegacyKey() {
+    return this.legacyKey;
+  }
+
   private long dirKeyPublishedMillis;
   public long getDirKeyPublishedMillis() {
     return this.dirKeyPublishedMillis;
@@ -311,54 +399,67 @@ public class RelayNetworkStatusVoteImpl
     return this.signingKeyDigest;
   }
 
-  private SortedMap<String, NetworkStatusEntry> statusEntries =
-      new TreeMap<String, NetworkStatusEntry>();
-  public SortedMap<String, NetworkStatusEntry> getStatusEntries() {
-    return new TreeMap<String, NetworkStatusEntry>(this.statusEntries);
+  private int networkStatusVersion;
+  public int getNetworkStatusVersion() {
+    return this.networkStatusVersion;
   }
-  public boolean containsStatusEntry(String fingerprint) {
-    return this.statusEntries.containsKey(fingerprint);
+
+  private List<Integer> consensusMethods;
+  public List<Integer> getConsensusMethods() {
+    return new ArrayList<Integer>(this.consensusMethods);
   }
-  public NetworkStatusEntry getStatusEntry(String fingerprint) {
-    return this.statusEntries.get(fingerprint);
+
+  private long publishedMillis;
+  public long getPublishedMillis() {
+    return this.publishedMillis;
   }
 
+  private long validAfterMillis;
+  public long getValidAfterMillis() {
+    return this.validAfterMillis;
+  }
 
-  private SortedMap<String, String> directorySignatures =
-      new TreeMap<String, String>();
-  public SortedMap<String, String> getDirectorySignatures() {
-    return new TreeMap<String, String>(this.directorySignatures);
+  private long freshUntilMillis;
+  public long getFreshUntilMillis() {
+    return this.freshUntilMillis;
   }
 
-  private void checkConsistency() {
-    if (this.networkStatusVersion == 0) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'network-status-version' line.");
-    }
-    if (this.validAfterMillis == 0L) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'valid-after' line.");
-    }
-    if (this.freshUntilMillis == 0L) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'fresh-until' line.");
-    }
-    if (this.validUntilMillis == 0L) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'valid-until' line.");
-    }
-    if (this.votingDelay.isEmpty()) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'voting-delay' line.");
-    }
-    if (this.knownFlags.isEmpty()) {
-      throw new RuntimeException("Consensus doesn't contain a "
-          + "'known-flags' line.");
-    }
-    if (this.statusEntries.isEmpty()) {
-      throw new RuntimeException("Consensus doesn't contain any 'r' "
-          + "lines.");
-    }
+  private long validUntilMillis;
+  public long getValidUntilMillis() {
+    return this.validUntilMillis;
+  }
+
+  private long voteSeconds;
+  public long getVoteSeconds() {
+    return this.voteSeconds;
+  }
+
+  private long distSeconds;
+  public long getDistSeconds() {
+    return this.distSeconds;
+  }
+
+  private List<String> recommendedClientVersions;
+  public List<String> getRecommendedClientVersions() {
+    return this.recommendedClientVersions == null ? null :
+        new ArrayList<String>(this.recommendedClientVersions);
+  }
+
+  private List<String> recommendedServerVersions;
+  public List<String> getRecommendedServerVersions() {
+    return this.recommendedServerVersions == null ? null :
+        new ArrayList<String>(this.recommendedServerVersions);
+  }
+
+  private SortedSet<String> knownFlags;
+  public SortedSet<String> getKnownFlags() {
+    return new TreeSet<String>(this.knownFlags);
+  }
+
+  private SortedMap<String, Integer> consensusParams;
+  public SortedMap<String, Integer> getConsensusParams() {
+    return this.consensusParams == null ? null:
+        new TreeMap<String, Integer>(this.consensusParams);
   }
 }
 
diff --git a/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java b/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java
new file mode 100644
index 0000000..8b62480
--- /dev/null
+++ b/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java
@@ -0,0 +1,574 @@
+/* Copyright 2011 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor.impl;
+
+import org.torproject.descriptor.RelayNetworkStatusVote;
+import org.torproject.descriptor.impl.RelayNetworkStatusVoteImpl;
+
+import java.util.*;
+
+import org.junit.*;
+import org.junit.rules.*;
+import static org.junit.Assert.*;
+
+/* TODO Add tests (and possibly a DirSourceLineBuilder) to test the
+ * following methods:
+ * - String getNickname();
+ * - String getIdentity();
+ * - String getAddress();
+ * - int getDirport();
+ * - int getOrport();
+ * - String getContactLine();
+ * - int getDirKeyCertificateVersion();
+ * - String getLegacyKey();
+ * - long getDirKeyPublishedMillis();
+ * - long getDirKeyExpiresMillis();
+ * - String getSigningKeyDigest();
+ */
+
+/* Test parsing of network status votes.  Some of the vote-parsing code is
+ * already tested in the consensus-parsing tests.  The tests in this class
+ * focus on the differences between votes and consensuses that are mostly
+ * in the directory header. */
+public class RelayNetworkStatusVoteImplTest {
+
+  /* Helper class to build a vote based on default data and modifications
+   * requested by test methods. */
+  private static class VoteBuilder {
+    private String networkStatusVersionLine = "network-status-version 3";
+    private static RelayNetworkStatusVote
+        createWithNetworkStatusVersionLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.networkStatusVersionLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String voteStatusLine = "vote-status vote";
+    private static RelayNetworkStatusVote
+        createWithVoteStatusLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.voteStatusLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String consensusMethodsLine =
+        "consensus-methods 1 2 3 4 5 6 7 8 9 10 11";
+    private static RelayNetworkStatusVote
+        createWithConsensusMethodsLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.consensusMethodsLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String publishedLine = "published 2011-11-30 08:50:01";
+    private static RelayNetworkStatusVote
+        createWithPublishedLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.publishedLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String validAfterLine = "valid-after 2011-11-30 09:00:00";
+    private static RelayNetworkStatusVote
+        createWithValidAfterLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.validAfterLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String freshUntilLine = "fresh-until 2011-11-30 10:00:00";
+    private static RelayNetworkStatusVote
+        createWithFreshUntilLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.freshUntilLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String validUntilLine = "valid-until 2011-11-30 12:00:00";
+    private static RelayNetworkStatusVote
+        createWithValidUntilLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.validUntilLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String votingDelayLine = "voting-delay 300 300";
+    private static RelayNetworkStatusVote
+        createWithVotingDelayLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.votingDelayLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String clientVersionsLine = "client-versions 0.2.1.31,"
+        + "0.2.2.34,0.2.3.6-alpha,0.2.3.7-alpha,0.2.3.8-alpha";
+    private static RelayNetworkStatusVote
+        createWithClientVersionsLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.clientVersionsLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String serverVersionsLine = "server-versions 0.2.1.31,"
+        + "0.2.2.34,0.2.3.6-alpha,0.2.3.7-alpha,0.2.3.8-alpha";
+    private static RelayNetworkStatusVote
+        createWithServerVersionsLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.serverVersionsLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String knownFlagsLine = "known-flags Authority BadExit Exit "
+        + "Fast Guard HSDir Named Running Stable Unnamed V2Dir Valid";
+    private static RelayNetworkStatusVote
+        createWithKnownFlagsLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.knownFlagsLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private String paramsLine = "params "
+        + "CircuitPriorityHalflifeMsec=30000 bwauthbestratio=1 "
+        + "bwauthcircs=1 bwauthdescbw=0 bwauthkp=10000 bwauthpid=1 "
+        + "bwauthtd=5000 bwauthti=50000 bwauthtidecay=5000 cbtnummodes=3 "
+        + "cbtquantile=80 circwindow=1000 refuseunknownexits=1";
+    private static RelayNetworkStatusVote
+        createWithParamsLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.paramsLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private List<String> dirSources = new ArrayList<String>();
+    private List<String> statusEntries = new ArrayList<String>();
+    private String directoryFooterLine = "directory-footer";
+    private static RelayNetworkStatusVote
+        createWithDirectoryFooterLine(String line)
+        throws DescriptorParseException {
+      VoteBuilder vb = new VoteBuilder();
+      vb.directoryFooterLine = line;
+      return new RelayNetworkStatusVoteImpl(vb.buildVote());
+    }
+    private List<String> directorySignatures = new ArrayList<String>();
+    private VoteBuilder() {
+      this.dirSources.add("dir-source urras "
+          + "80550987E1D626E3EBA5E5E75A458DE0626D088C 208.83.223.34 "
+          + "208.83.223.34 443 80\n"
+          + "contact 4096R/E012B42D Jacob Appelbaum "
+          + "<jacob@appelbaum.net>\n"
+          + "dir-key-certificate-version 3\n"
+          + "fingerprint 80550987E1D626E3EBA5E5E75A458DE0626D088C\n"
+          + "dir-key-published 2011-04-27 05:34:37\n"
+          + "dir-key-expires 2012-04-27 05:34:37\n"
+          + "dir-identity-key\n"
+          + "-----BEGIN RSA PUBLIC KEY-----\n"
+          + "MIIBigKCAYEAtKpuLgVK25sfScjsxfVU1ljofrDygt9GP7bNJl/rghX42KUT"
+          + "975W\nrGp/fbhF7p+FcKCzNOhJFINQbRf/5E3lN8mzoamIU43QqQ9RRVf946"
+          + "88UsazVsAN\nNVT0v9J0cr387WePjenRuIE1MmiP0nmw/XdvbPTayqax7VYl"
+          + "cUMXGHl8DnWix1EN\nRwmeig+JBte0JS12oo2HG9zcSfjLJVjY6ZmvRrVycX"
+          + "iRxGc/JgNlSrV4cxUNykaB\nJ6pO6J499OZfQu7m1vAPTENrVJ4yEfRGRwFI"
+          + "Y+d/s8BkKcaiWtXAfTe31uBI6GEH\nmS3HNu1JVSuoaUiQIvVYDLMfBvMcNy"
+          + "Ax97UT1l6E0Tn6a7pgChrquGwXai1xGzk8\n58aXwdSFoFBSTCkyemopq5H2"
+          + "0p/nkPAO0pHL1kTvcaKz9CEj4XcKm+kOmzejYmIa\nkbWNcRpXPiUZ+xmwGt"
+          + "sq30xrzqiONmERkxqlmf7bVQPFvh3Kz6hGcmTBhTbHSe9h\nzDgmdaTNn3EH"
+          + "AgMBAAE=\n"
+          + "-----END RSA PUBLIC KEY-----\n"
+          + "dir-signing-key\n"
+          + "-----BEGIN RSA PUBLIC KEY-----\n"
+          + "MIGJAoGBAN05qyHFQlTqykMP8yLuD4G2UuYulD4Xs8iSX5uqF+WGsUA1E4zZ"
+          + "h48h\nDFj8+drFiCu3EqhMEmVG4ACtJK2uz6D1XohUsbPWTR6LSnWJ8q6/zf"
+          + "TSLumBGsN7\nPUXyMNjwRKL6UvrcbYk1d2mRBLO7SAP/sFW5fHhIBVeLIWrz"
+          + "Q19rAgMBAAE=\n"
+          + "-----END RSA PUBLIC KEY-----\n"
+          + "dir-key-crosscert\n"
+          + "-----BEGIN ID SIGNATURE-----\n"
+          + "rPBFn6IJ6TvAHj4pSwlg+RTn1fP89JGSVa08wuyJr5dAvZsdakQXvRjamT9o"
+          + "JUaZ\nnY5Rl/tRlGuSQ0BglTPPKoXdKERK0FUr9f0EKrQy7NDUgE2j9losiR"
+          + "uyKzhA3neZ\nK4yF8bhqAwM51u7fzAhIjNeRif9c04rhFJJCseco84w=\n"
+          + "-----END ID SIGNATURE-----\n"
+          + "dir-key-certification\n"
+          + "-----BEGIN SIGNATURE-----\n"
+          + "hPSh6FuohNF5ccjiMbkvr8cZJwGFuL11cNtwN9k0X3pUdFZVATIEkqBe7z+r"
+          + "E2PX\nPw+BGyC6wYAieoTVIhLpwKqd7DXLYjuhPZ28+7MQaDL01AqYeRp5PT"
+          + "01PxrFY0Um\nlVf95uqUitgvDT76Ne4ExWk6UvGlYB9OBgBySZz8VWe9znoM"
+          + "qb0uHn/p8IzqTApT\nAxRWXBHClntMeRqtGxaj8DcdJFn8yMxQiZG7MfDg2s"
+          + "q2ySPJyGlN+neoVDVhZiDI\n9LTNmw60gWlUp2erFeam8Mo1ZBC4DPNjQEm6"
+          + "QeHZFZMkhDuO6SwS/FL712A42+Co\nYtMaVot/p5FG2ZSBXbgl2XP5/z8ELn"
+          + "pmXqMbPAoWRo3BPNSJkIQQNog8Q5ZrK+av\nZDw5eGPltGKsXOkvuzIMM8nB"
+          + "eAnDPDgYvzrIFObEGbvY/P8mzVAZxp3Yz+sRtNel\nC1SWz/Fx+Saex5oI7D"
+          + "J3xtSD4XqKb/wYwZFT8IxDYq1t2tFXdHxd4QPRVcvc0zYC\n"
+          + "-----END SIGNATURE-----");
+      this.statusEntries.add("r right2privassy3 "
+          + "ADQ6gCT3DiFHKPDFr3rODBUI8HM lJY5Vf7kXec+VdkGW2flEsfkFC8 "
+          + "2011-11-12 00:03:40 50.63.8.215 9023 0\n"
+          + "s Exit Fast Guard Running Stable Valid\n"
+          + "opt v Tor 0.2.1.29 (r8e9b25e6c7a2e70c)\n"
+          + "w Bandwidth=297 Measured=73\n"
+          + "p accept 80,1194,1220,1293,1500,1533,1677,1723,1863,"
+          + "2082-2083,2086-2087,2095-2096,2102-2104,3128,3389,3690,4321,"
+          + "4643,5050,5190,5222-5223,5228,5900,6660-6669,6679,6697,8000,"
+          + "8008,8074,8080,8087-8088,8443,8888,9418,9999-10000,19294,"
+          + "19638\n"
+          + "m 8,9,10,11 sha256=9ciEx9t0McXk9A06I7qwN7pxuNOdpCP64RV/6cx2Zkc");
+      this.directorySignatures.add("directory-signature "
+          + "80550987E1D626E3EBA5E5E75A458DE0626D088C "
+          + "EEB9299D295C1C815E289FBF2F2BBEA5F52FDD19\n"
+          + "-----BEGIN SIGNATURE-----\n"
+          + "iHEU3Iidya5RIrjyYgv8tlU0R+rF56/3/MmaaZi0a67e7ZkISfQ4dghScHxn"
+          + "F3Yh\nqXVaaoP07r6Ta+s0g1Zijm3lms50Nk/4tV2p8Y63c3F4Q3DAnK40Oi"
+          + "kfOIwEj+Ny\n+zBRQssP3hPhTPOj/A7o3mZZwtL6x1sxpeu/nME1l5E=\n"
+          + "-----END SIGNATURE-----");
+    }
+    private byte[] buildVote() {
+      StringBuilder sb = new StringBuilder();
+      this.appendHeader(sb);
+      this.appendBody(sb);
+      this.appendFooter(sb);
+      return sb.toString().getBytes();
+    }
+    private void appendHeader(StringBuilder sb) {
+      if (this.networkStatusVersionLine != null) {
+        sb.append(this.networkStatusVersionLine + "\n");
+      }
+      if (this.voteStatusLine != null) {
+        sb.append(this.voteStatusLine + "\n");
+      }
+      if (this.consensusMethodsLine != null) {
+        sb.append(this.consensusMethodsLine + "\n");
+      }
+      if (this.publishedLine != null) {
+        sb.append(this.publishedLine + "\n");
+      }
+      if (this.validAfterLine != null) {
+        sb.append(this.validAfterLine + "\n");
+      }
+      if (this.freshUntilLine != null) {
+        sb.append(this.freshUntilLine + "\n");
+      }
+      if (this.validUntilLine != null) {
+        sb.append(this.validUntilLine + "\n");
+      }
+      if (this.votingDelayLine != null) {
+        sb.append(this.votingDelayLine + "\n");
+      }
+      if (this.clientVersionsLine != null) {
+        sb.append(this.clientVersionsLine + "\n");
+      }
+      if (this.serverVersionsLine != null) {
+        sb.append(this.serverVersionsLine + "\n");
+      }
+      if (this.knownFlagsLine != null) {
+        sb.append(this.knownFlagsLine + "\n");
+      }
+      if (this.paramsLine != null) {
+        sb.append(this.paramsLine + "\n");
+      }
+      for (String dirSource : this.dirSources) {
+        sb.append(dirSource + "\n");
+      }
+    }
+    private void appendBody(StringBuilder sb) {
+      for (String statusEntry : this.statusEntries) {
+        sb.append(statusEntry + "\n");
+      }
+    }
+    private void appendFooter(StringBuilder sb) {
+      if (this.directoryFooterLine != null) {
+        sb.append(this.directoryFooterLine + "\n");
+      }
+      for (String directorySignature : this.directorySignatures) {
+        sb.append(directorySignature + "\n");
+      }
+    }
+  }
+
+  @Test()
+  public void testSampleVote() throws DescriptorParseException {
+    VoteBuilder vb = new VoteBuilder();
+    RelayNetworkStatusVote vote =
+        new RelayNetworkStatusVoteImpl(vb.buildVote());
+    assertEquals(3, vote.getNetworkStatusVersion());
+    List<Integer> consensusMethods = Arrays.asList(
+        new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11});
+    assertEquals(vote.getConsensusMethods(), consensusMethods);
+    assertEquals(1322643001000L, vote.getPublishedMillis());
+    assertEquals(1322643600000L, vote.getValidAfterMillis());
+    assertEquals(1322647200000L, vote.getFreshUntilMillis());
+    assertEquals(1322654400000L, vote.getValidUntilMillis());
+    assertEquals(300L, vote.getVoteSeconds());
+    assertEquals(300L, vote.getDistSeconds());
+    assertTrue(vote.getKnownFlags().contains("Running"));
+    assertEquals(30000, (int) vote.getConsensusParams().get(
+        "CircuitPriorityHalflifeMsec"));
+    assertEquals("Tor 0.2.1.29 (r8e9b25e6c7a2e70c)",
+        vote.getStatusEntry("00343A8024F70E214728F0C5AF7ACE0C1508F073").
+        getVersion());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionNoLine()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionNewLine()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version 3\n");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionNewLineSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version 3\n ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionPrefixLineAtChar()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "@vote\nnetwork-status-version 3");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionPrefixLine()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "directory-footer\nnetwork-status-version 3");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionPrefixLinePoundChar()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "#vote\nnetwork-status-version 3");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionNoSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionOneSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersion42()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version 42");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionFourtyTwo()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        "network-status-version FourtyTwo");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNetworkStatusVersionSpaceBefore()
+      throws DescriptorParseException {
+    VoteBuilder.createWithNetworkStatusVersionLine(
+        " network-status-version 3");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusSpaceBefore() throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine(" vote-status vote");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusNoSpace() throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine("vote-status");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusOneSpace() throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine("vote-status ");
+  }
+
+  @Test()
+  public void testVoteStatusVoteOneSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine("vote-status vote ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusConsensus() throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine("vote-status consensus");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVoteStatusTheMagicVoteStatus()
+      throws DescriptorParseException {
+    VoteBuilder.createWithVoteStatusLine(
+        "vote-status TheMagicVoteStatus");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodNoLine()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodNoSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine("consensus-methods");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodOneSpace()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine("consensus-methods ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodEleven()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine(
+        "consensus-methods eleven");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodMinusOne()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine("consensus-methods -1");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodNinePeriod()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine("consensus-methods "
+        + "999999999999999999999999999999999999999999999999999999999999");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testConsensusMethodTwoLines()
+      throws DescriptorParseException {
+    VoteBuilder.createWithConsensusMethodsLine(
+        "consensus-method 1\nconsensus-method 1");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testPublishedNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithPublishedLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidAfterNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithValidAfterLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidAfterNoSpace() throws DescriptorParseException {
+    VoteBuilder.createWithValidAfterLine("valid-after");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidAfterOneSpace() throws DescriptorParseException {
+    VoteBuilder.createWithValidAfterLine("valid-after ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidAfterLongAgo() throws DescriptorParseException {
+    VoteBuilder.createWithValidAfterLine("valid-after long ago");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidAfterFeb30() throws DescriptorParseException {
+    VoteBuilder.createWithValidAfterLine(
+        "valid-after 2011-02-30 09:00:00");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFreshUntilNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithFreshUntilLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFreshUntilAroundTen() throws DescriptorParseException {
+    VoteBuilder.createWithFreshUntilLine(
+        "fresh-until 2011-11-30 around ten");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testValidUntilTomorrowMorning()
+      throws DescriptorParseException {
+    VoteBuilder.createWithValidUntilLine(
+        "valid-until tomorrow morning");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelayNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelayNoSpace() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine("voting-delay");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelayOneSpace() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine("voting-delay ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelayTriple() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine(
+        "voting-delay 300 300 300");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelaySingle() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine("voting-delay 300");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testVotingDelayOneTwo() throws DescriptorParseException {
+    VoteBuilder.createWithVotingDelayLine("voting-delay one two");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testClientVersionsComma() throws DescriptorParseException {
+    VoteBuilder.createWithClientVersionsLine("client-versions ,");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testClientVersionsCommaVersion()
+      throws DescriptorParseException {
+    VoteBuilder.createWithClientVersionsLine(
+        "client-versions ,0.2.2.34");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testKnownFlagsNoLine() throws DescriptorParseException {
+    VoteBuilder.createWithKnownFlagsLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testKnownFlagsNoSpace() throws DescriptorParseException {
+    VoteBuilder.createWithKnownFlagsLine("known-flags");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testKnownFlagsOneSpace() throws DescriptorParseException {
+    VoteBuilder.createWithKnownFlagsLine("known-flags ");
+  }
+}
+

    

[tor-commits] [metrics-lib/master] Make votes use the general network-status parsing code.

karsten＠torproject.org