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 "); + } +} +