Kaladaran/briar
0
0
Fork 0
mirror of https://code.briarproject.org/briar/briar.git synced 2026-02-16 04:39:54 +01:00
Code Issues Projects Releases Wiki Activity

Cleaned up serial and protocol packages in preparation for user-defined types.

Browse Source
This commit is contained in:
akwizgran
2011-07-18 14:33:41 +01:00
parent 308a7017be
commit 0bc8a31749
20 changed files with 378 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/build.xml
View File

@@ -21,7 +21,7 @@
<test name='net.sf.briar.i18n.I18nTest'/>
<test name='net.sf.briar.invitation.InvitationWorkerTest'/>
<test name='net.sf.briar.protocol.BundleReadWriteTest'/>
<test name='net.sf.briar.protocol.SigningStreamTest'/>
<test name='net.sf.briar.protocol.ConsumersTest'/>
<test name='net.sf.briar.serial.ReaderImplTest'/>
<test name='net.sf.briar.serial.WriterImplTest'/>
<test name='net.sf.briar.setup.SetupWorkerTest'/>

7
test/net/sf/briar/protocol/BundleReadWriteTest.java
View File

@@ -36,6 +36,7 @@ import net.sf.briar.api.protocol.MessageParser;
import net.sf.briar.api.protocol.UniqueId;
import net.sf.briar.api.serial.Raw;
import net.sf.briar.api.serial.RawByteArray;
import net.sf.briar.api.serial.Reader;
import net.sf.briar.api.serial.ReaderFactory;
import net.sf.briar.api.serial.WriterFactory;
import net.sf.briar.serial.SerialModule;
@@ -125,7 +126,8 @@ public class BundleReadWriteTest extends TestCase {
MessageParser messageParser =
new MessageParserImpl(keyParser, sig, dig, rf);
FileInputStream in = new FileInputStream(bundle);
BundleReader r = new BundleReaderImpl(in, rf, keyPair.getPublic(), sig,
Reader reader = rf.createReader(in);
BundleReader r = new BundleReaderImpl(reader, keyPair.getPublic(), sig,
dig, messageParser, new HeaderFactoryImpl(),
new BatchFactoryImpl());
@@ -164,7 +166,8 @@ public class BundleReadWriteTest extends TestCase {
MessageParser messageParser =
new MessageParserImpl(keyParser, sig, dig, rf);
FileInputStream in = new FileInputStream(bundle);
BundleReader r = new BundleReaderImpl(in, rf, keyPair.getPublic(), sig,
Reader reader = rf.createReader(in);
BundleReader r = new BundleReaderImpl(reader, keyPair.getPublic(), sig,
dig, messageParser, new HeaderFactoryImpl(),
new BatchFactoryImpl());

73
test/net/sf/briar/protocol/ConsumersTest.java Normal file
View File

@@ -0,0 +1,73 @@
package net.sf.briar.protocol;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.Signature;
import java.util.Arrays;
import java.util.Random;
import junit.framework.TestCase;
import net.sf.briar.api.serial.FormatException;
import org.junit.Test;
public class ConsumersTest extends TestCase {
private static final String SIGNATURE_ALGO = "SHA256withRSA";
private static final String KEY_PAIR_ALGO = "RSA";
private static final String DIGEST_ALGO = "SHA-256";
@Test
public void testSigningConsumer() throws Exception {
Signature s = Signature.getInstance(SIGNATURE_ALGO);
KeyPair k = KeyPairGenerator.getInstance(KEY_PAIR_ALGO).genKeyPair();
byte[] data = new byte[1234];
// Generate some random data and sign it
new Random().nextBytes(data);
s.initSign(k.getPrivate());
s.update(data);
byte[] sig = s.sign();
// Check that feeding a SigningConsumer generates the same signature
s.initSign(k.getPrivate());
SigningConsumer sc = new SigningConsumer(s);
sc.write(data[0]);
sc.write(data, 1, data.length - 2);
sc.write(data[data.length - 1]);
byte[] sig1 = s.sign();
assertTrue(Arrays.equals(sig, sig1));
}
@Test
public void testDigestingConsumer() throws Exception {
MessageDigest m = MessageDigest.getInstance(DIGEST_ALGO);
byte[] data = new byte[1234];
// Generate some random data and digest it
new Random().nextBytes(data);
m.reset();
m.update(data);
byte[] dig = m.digest();
// Check that feeding a DigestingConsumer generates the same digest
m.reset();
DigestingConsumer dc = new DigestingConsumer(m);
dc.write(data[0]);
dc.write(data, 1, data.length - 2);
dc.write(data[data.length - 1]);
byte[] dig1 = m.digest();
assertTrue(Arrays.equals(dig, dig1));
}
@Test
public void testCountingConsumer() throws Exception {
byte[] data = new byte[1234];
CountingConsumer cc = new CountingConsumer(data.length);
cc.write(data[0]);
cc.write(data, 1, data.length - 2);
cc.write(data[data.length - 1]);
assertEquals(data.length, cc.getCount());
try {
cc.write((byte) 0);
assertTrue(false);
} catch(FormatException expected) {}
}
}

160
test/net/sf/briar/protocol/SigningStreamTest.java
View File

@@ -1,160 +0,0 @@
package net.sf.briar.protocol;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.Signature;
import java.util.Arrays;
import java.util.Random;
import junit.framework.TestCase;
import org.junit.Test;
public class SigningStreamTest extends TestCase {
private static final String SIGNATURE_ALGO = "SHA256withRSA";
private static final String KEY_PAIR_ALGO = "RSA";
private static final String DIGEST_ALGO = "SHA-256";
private final KeyPair keyPair;
private final Signature sig;
private final MessageDigest dig;
private final Random random;
public SigningStreamTest() throws Exception {
super();
keyPair = KeyPairGenerator.getInstance(KEY_PAIR_ALGO).generateKeyPair();
sig = Signature.getInstance(SIGNATURE_ALGO);
dig = MessageDigest.getInstance(DIGEST_ALGO);
random = new Random();
}
@Test
public void testOutputStreamOutputMatchesInput() throws Exception {
byte[] input = new byte[1000];
random.nextBytes(input);
ByteArrayOutputStream out = new ByteArrayOutputStream();
SigningDigestingOutputStream signOut =
new SigningDigestingOutputStream(out, sig, dig);
sig.initSign(keyPair.getPrivate());
signOut.setSigning(true);
signOut.write(input, 0, 500);
signOut.setSigning(false);
signOut.write(input, 500, 250);
signOut.setSigning(true);
signOut.write(input, 750, 250);
byte[] output = out.toByteArray();
assertTrue(Arrays.equals(input, output));
}
@Test
public void testInputStreamOutputMatchesInput() throws Exception {
byte[] input = new byte[1000];
random.nextBytes(input);
ByteArrayInputStream in = new ByteArrayInputStream(input);
SigningDigestingInputStream signIn =
new SigningDigestingInputStream(in, sig, dig);
sig.initVerify(keyPair.getPublic());
byte[] output = new byte[1000];
signIn.setSigning(true);
assertEquals(500, signIn.read(output, 0, 500));
signIn.setSigning(false);
assertEquals(250, signIn.read(output, 500, 250));
signIn.setSigning(true);
assertEquals(250, signIn.read(output, 750, 250));
assertTrue(Arrays.equals(input, output));
}
@Test
public void testVerificationLagsByOneByte() throws Exception {
byte[] input = new byte[1000];
random.nextBytes(input);
ByteArrayOutputStream out = new ByteArrayOutputStream();
SigningDigestingOutputStream signOut =
new SigningDigestingOutputStream(out, sig, dig);
sig.initSign(keyPair.getPrivate());
// Sign bytes 0-499, skip bytes 500-749, sign bytes 750-999
signOut.setSigning(true);
signOut.write(input, 0, 500);
signOut.setSigning(false);
signOut.write(input, 500, 250);
signOut.setSigning(true);
signOut.write(input, 750, 250);
byte[] signature = sig.sign();
ByteArrayInputStream in = new ByteArrayInputStream(input);
SigningDigestingInputStream signIn =
new SigningDigestingInputStream(in, sig, dig);
sig.initVerify(keyPair.getPublic());
byte[] output = new byte[1000];
// Consume a lookahead byte
assertEquals(1, signIn.read(output, 0, 1));
// All the offsets are increased by 1 because of the lookahead byte
signIn.setSigning(true);
assertEquals(500, signIn.read(output, 1, 500));
signIn.setSigning(false);
assertEquals(250, signIn.read(output, 501, 250));
signIn.setSigning(true);
assertEquals(249, signIn.read(output, 751, 249));
// Have to reach EOF for the lookahead byte to be processed
assertEquals(-1, signIn.read());
assertTrue(Arrays.equals(input, output));
assertTrue(sig.verify(signature));
}
@Test
public void testDigestionLagsByOneByte() throws Exception {
byte[] input = new byte[1000];
random.nextBytes(input);
ByteArrayOutputStream out = new ByteArrayOutputStream();
SigningDigestingOutputStream signOut =
new SigningDigestingOutputStream(out, sig, dig);
dig.reset();
// Digest bytes 0-499, skip bytes 500-749, digest bytes 750-999
signOut.setDigesting(true);
signOut.write(input, 0, 500);
signOut.setDigesting(false);
signOut.write(input, 500, 250);
signOut.setDigesting(true);
signOut.write(input, 750, 250);
byte[] hash = dig.digest();
ByteArrayInputStream in = new ByteArrayInputStream(input);
SigningDigestingInputStream signIn =
new SigningDigestingInputStream(in, sig, dig);
dig.reset();
byte[] output = new byte[1000];
// Consume a lookahead byte
assertEquals(1, signIn.read(output, 0, 1));
// All the offsets are increased by 1 because of the lookahead byte
signIn.setDigesting(true);
assertEquals(500, signIn.read(output, 1, 500));
signIn.setDigesting(false);
assertEquals(250, signIn.read(output, 501, 250));
signIn.setDigesting(true);
assertEquals(249, signIn.read(output, 751, 249));
// Have to reach EOF for the lookahead byte to be processed
assertEquals(-1, signIn.read());
assertTrue(Arrays.equals(input, output));
assertTrue(Arrays.equals(hash, dig.digest()));
}
}

83
test/net/sf/briar/serial/ReaderImplTest.java
View File

@@ -3,13 +3,11 @@ package net.sf.briar.serial;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import junit.framework.TestCase;
import net.sf.briar.api.serial.FormatException;
import net.sf.briar.api.serial.Raw;
import net.sf.briar.api.serial.RawByteArray;
import net.sf.briar.util.StringUtils;
@@ -121,38 +119,11 @@ public class ReaderImplTest extends TestCase {
}
@Test
public void testReadUtf8() throws IOException {
public void testReadString() throws IOException {
setContents("F703666F6F" + "F703666F6F" + "F700");
assertEquals("foo", r.readUtf8());
assertEquals("foo", r.readUtf8());
assertEquals("", r.readUtf8());
assertTrue(r.eof());
}
@Test
public void testReadUtf8LimitNotExceeded() throws IOException {
setContents("F703666F6F");
r.setReadLimit(3);
assertEquals("foo", r.readUtf8());
assertTrue(r.eof());
}
@Test
public void testReadUtf8LimitExceeded() throws IOException {
setContents("F703666F6F");
r.setReadLimit(2);
try {
r.readUtf8();
assertTrue(false);
} catch(FormatException expected) {}
}
@Test
public void testReadUtf8LimitReset() throws IOException {
setContents("F703666F6F");
r.setReadLimit(2);
r.resetReadLimit();
assertEquals("foo", r.readUtf8());
assertEquals("foo", r.readString());
assertEquals("foo", r.readString());
assertEquals("", r.readString());
assertTrue(r.eof());
}
@@ -165,33 +136,6 @@ public class ReaderImplTest extends TestCase {
assertTrue(r.eof());
}
@Test
public void testReadRawLimitNotExceeded() throws IOException {
setContents("F603010203");
r.setReadLimit(3);
assertTrue(Arrays.equals(new byte[] {1, 2, 3}, r.readRaw()));
assertTrue(r.eof());
}
@Test
public void testReadRawMaxLengthExceeded() throws IOException {
setContents("F603010203");
r.setReadLimit(2);
try {
r.readRaw();
assertTrue(false);
} catch(FormatException expected) {}
}
@Test
public void testReadRawLimitReset() throws IOException {
setContents("F603010203");
r.setReadLimit(2);
r.resetReadLimit();
assertTrue(Arrays.equals(new byte[] {1, 2, 3}, r.readRaw()));
assertTrue(r.eof());
}
@Test
public void testReadDefiniteList() throws IOException {
setContents("F5" + "03" + "01" + "F703666F6F" + "FC0080");
@@ -261,7 +205,7 @@ public class ReaderImplTest extends TestCase {
assertFalse(r.hasListEnd());
assertEquals((byte) 1, r.readIntAny());
assertFalse(r.hasListEnd());
assertEquals("foo", r.readUtf8());
assertEquals("foo", r.readString());
assertFalse(r.hasListEnd());
assertEquals((short) 128, r.readIntAny());
assertTrue(r.hasListEnd());
@@ -300,7 +244,7 @@ public class ReaderImplTest extends TestCase {
assertTrue(r.hasMapStart());
r.readMapStart();
assertFalse(r.hasMapEnd());
assertEquals("foo", r.readUtf8());
assertEquals("foo", r.readString());
assertFalse(r.hasMapEnd());
assertEquals((byte) 123, r.readIntAny());
assertFalse(r.hasMapEnd());
@@ -345,25 +289,10 @@ public class ReaderImplTest extends TestCase {
assertTrue(r.eof());
}
@Test
public void testGetRawBytesRead() throws IOException {
setContents("F4" + "00" + "F4" + "00");
assertEquals(0L, r.getRawBytesRead());
Map<Object, Object> m = r.readMap(Object.class, Object.class);
assertEquals(2L, r.getRawBytesRead());
assertEquals(Collections.emptyMap(), m);
m = r.readMap(Object.class, Object.class);
assertEquals(4L, r.getRawBytesRead());
assertEquals(Collections.emptyMap(), m);
assertTrue(r.eof());
assertEquals(4L, r.getRawBytesRead());
}
@Test
public void testReadEmptyInput() throws IOException {
setContents("");
assertTrue(r.eof());
assertEquals(0L, r.getRawBytesRead());
}
private void setContents(String hex) {

8
test/net/sf/briar/serial/WriterImplTest.java
View File

@@ -129,7 +129,7 @@ public class WriterImplTest extends TestCase {
@Test
public void testWriteUtf8() throws IOException {
w.writeUtf8("foo");
w.writeString("foo");
// UTF-8 tag, length as uint7, UTF-8 bytes
checkContents("F7" + "03" + "666F6F");
}
@@ -170,7 +170,7 @@ public class WriterImplTest extends TestCase {
public void testWriteIndefiniteList() throws IOException {
w.writeListStart();
w.writeIntAny((byte) 1); // Written as uint7
w.writeUtf8("foo");
w.writeString("foo");
w.writeIntAny(128L); // Written as an int16
w.writeListEnd();
checkContents("F3" + "01" + "F703666F6F" + "FC0080" + "F1");
@@ -179,7 +179,7 @@ public class WriterImplTest extends TestCase {
@Test
public void testWriteIndefiniteMap() throws IOException {
w.writeMapStart();
w.writeUtf8("foo");
w.writeString("foo");
w.writeIntAny(123); // Written as a uint7
w.writeRaw(new byte[] {});
w.writeNull();
@@ -212,6 +212,6 @@ public class WriterImplTest extends TestCase {
byte[] expected = StringUtils.fromHexString(hex);
assertTrue(StringUtils.toHexString(out.toByteArray()),
Arrays.equals(expected, out.toByteArray()));
assertEquals(expected.length, w.getRawBytesWritten());
assertEquals(expected.length, w.getBytesWritten());
}
}