Changeset 60efd0b for core


Ignore:
Timestamp:
Dec 2, 2017 5:25:09 PM (3 years ago)
Author:
str4d <str4d@…>
Branches:
master
Children:
b8eeb72
Parents:
c36905a
Message:

Migrate net.i2p.data tests to JUnit 4

Location:
core
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • core/build.gradle

    rc36905a r60efd0b  
    1818        java {
    1919            srcDir 'java/test/junit'
     20            exclude 'net/i2p/AllCoreTests.java'
     21            exclude 'net/i2p/data/DataTestSuite.java'
     22            exclude 'net/i2p/data/i2cp/I2CPTestSuite.java'
    2023        }
    2124        resources {
  • core/java/test/junit/net/i2p/AllCoreTests.java

    rc36905a r60efd0b  
    99 */
    1010
    11 import junit.framework.Test;
    12 import junit.framework.TestSuite;
     11import org.junit.runners.Suite;
     12import org.junit.runner.RunWith;
    1313
    1414/**
    15  * @author Comwiz
     15 * @author str4d
    1616 */
     17@RunWith(Suite.class)
     18@Suite.SuiteClasses({
     19    net.i2p.client.I2PClientTestSuite.class,
     20    net.i2p.crypto.CryptoTestSuite.class,
     21    net.i2p.data.DataTestSuite.class,
     22    net.i2p.stat.StatTestSuite.class,
     23    net.i2p.util.UtilTestSuite.class,
     24})
    1725public class AllCoreTests {
    18    
    19     public static Test suite() {
    20         TestSuite suite = new TestSuite("net.i2p.AllCoreTests");
    21        
    22         suite.addTest(net.i2p.client.I2PClientTestSuite.suite());
    23         suite.addTest(net.i2p.crypto.CryptoTestSuite.suite());
    24         suite.addTest(net.i2p.data.DataTestSuite.suite());
    25         suite.addTest(net.i2p.stat.StatTestSuite.suite());
    26         suite.addTest(net.i2p.util.UtilTestSuite.suite());
    27        
    28         return suite;
    29     }
    3026}
  • core/java/test/junit/net/i2p/data/Base64Test.java

    rc36905a r60efd0b  
    99 */
    1010 
    11 import junit.framework.TestCase;
     11import static org.junit.Assert.*;
     12
     13import org.junit.Test;
    1214 
    13 public class Base64Test extends TestCase{
     15public class Base64Test {
     16    @Test
    1417    public void testBase64(){
    1518        String orig = "you smell";
     
    1821        String transformed = new String(decoded);
    1922        assertTrue(orig.equals(transformed));
    20            
     23
    2124        byte all[] = new byte[256];
    2225        for (int i = 0; i < all.length; i++)
  • core/java/test/junit/net/i2p/data/BooleanTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315
    14 import junit.framework.TestCase;
     16import org.junit.Test;
    1517
    1618/**
     
    1921 * @author jrandom
    2022 */
    21 public class BooleanTest extends TestCase{
    22    
     23public class BooleanTest {
    2324    @SuppressWarnings("deprecation")
     25    @Test
    2426    public void testBoolean() throws Exception{
    2527        byte[] temp = null;
    26        
     28
    2729        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    28        
     30
    2931        DataHelper.writeBoolean(baos, Boolean.TRUE);
    3032        temp = baos.toByteArray();
    31        
    32        
     33
     34
    3335        Boolean b = null;
    3436        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    35        
     37
    3638        b = DataHelper.readBoolean(bais);
    37        
     39
    3840        assertEquals(Boolean.TRUE, b);
    3941    }
    40    
     42
    4143}
  • core/java/test/junit/net/i2p/data/DataHelperTest.java

    rc36905a r60efd0b  
    11package net.i2p.data;
     2
     3import static org.junit.Assert.*;
    24
    35import java.io.ByteArrayInputStream;
     
    911import java.util.TimeZone;
    1012
    11 import junit.framework.TestCase;
     13import org.junit.Test;
    1214
    1315/**
     
    1517 *
    1618 */
    17 public class DataHelperTest extends TestCase{
    18    
     19public class DataHelperTest {
     20
    1921    /**
    2022     * Test to/from/read/writeLong with every 1, 2, and 4 byte value, as
    2123     * well as some 8 byte values.
    2224     */
     25    @Test
    2326    public void testLong() throws Exception{
    2427        for (int i = 0; i <= 0xFF; i+=4)
     
    4447        DataHelper.toLong(extract2, 0, numBytes, value);
    4548        assertTrue(DataHelper.eq(extract, extract2));
    46        
     49
    4750        long read = DataHelper.fromLong(extract, 0, numBytes);
    4851        assertTrue(read == value);
    49        
     52
    5053        ByteArrayInputStream bais = new ByteArrayInputStream(written);
    5154        read = DataHelper.readLong(bais, numBytes);
     
    5356        read = DataHelper.fromLong(written, 0, numBytes);
    5457        assertTrue(read == value);
    55        
     58
    5659    }
    5760
     61    @Test
    5862    public void testDate() throws Exception{
    5963        TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
     
    6670        cal.set(Calendar.SECOND, 0);
    6771        checkDate(cal.getTime());
    68        
     72
    6973        cal.set(Calendar.SECOND, 1);
    7074        checkDate(cal.getTime());
    71        
     75
    7276        cal.set(Calendar.YEAR, 1999);
    7377        cal.set(Calendar.MONTH, 11);
     
    7781        cal.set(Calendar.SECOND, 59);
    7882        checkDate(cal.getTime());
    79        
     83
    8084        cal.set(Calendar.YEAR, 2000);
    8185        cal.set(Calendar.MONTH, 0);
     
    8589        cal.set(Calendar.SECOND, 0);
    8690        checkDate(cal.getTime());
    87        
     91
    8892        cal.setTimeInMillis(System.currentTimeMillis());
    8993        checkDate(cal.getTime());
    90        
     94
    9195        cal.set(Calendar.SECOND, cal.get(Calendar.SECOND)+10);
    9296        checkDate(cal.getTime());
     
    106110        assertTrue(error);
    107111    }
    108    
     112
    109113    @SuppressWarnings("deprecation")
    110114    private void checkDate(Date when) throws Exception{
     
    116120        assertEquals(when.getTime(), time.getTime());
    117121    }
    118    
     122
     123    @Test
    119124    public void testCompress() throws Exception{
    120125        Random r = new Random();
     
    126131            byte decompressed[] = DataHelper.decompress(compressed);
    127132            assertTrue(DataHelper.eq(data, decompressed));
    128            
    129133        }
    130134    }
    131135
     136    @Test
    132137    public void testSkip() throws Exception {
    133138        final int sz = 256;
     
    138143            fail();
    139144        } catch (IOException ioe) {}
    140        
     145
    141146        DataHelper.skip(tis, 0);
    142        
     147
    143148        try {
    144149            DataHelper.skip(tis, -1);
  • core/java/test/junit/net/i2p/data/DataStructureImplTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.IOException;
    1214import java.io.InputStream;
    1315import java.io.OutputStream;
    1416
    15 import junit.framework.TestCase;
     17import org.junit.Before;
     18import org.junit.Rule;
     19import org.junit.Test;
     20import org.junit.rules.ExpectedException;
    1621
    1722/**
    1823 * @author Comwiz
    1924 */
    20 public class DataStructureImplTest extends TestCase{
     25public class DataStructureImplTest {
    2126    DataStructure _struct;
    22    
    23     protected void setUp(){
     27
     28    @Rule
     29    public ExpectedException exception = ExpectedException.none();
     30
     31    @Before
     32    public void setUp(){
    2433        _struct = new DataStructureImpl(){
    2534            private int x = 0;
     
    2837                    throw new DataFormatException("let it enfold you", new Exception());
    2938                else
    30                     throw new IOException();   
     39                    throw new IOException();
    3140            }
    3241            public void readBytes(InputStream in) throws IOException{
     
    3544        };
    3645    }
    37    
    38     public void testNulls() throws Exception{
     46
     47    @Test
     48    public void toBase64ReturnsNull() throws Exception{
    3949        assertNull(_struct.toBase64());
    40        
    41         boolean error = false;
    42         try{
    43             _struct.fromBase64(null);
    44         }catch(DataFormatException dfe){
    45             error = true;
    46         }
    47         assertTrue(error);
    48        
     50    }
     51
     52    @Test
     53    public void fromBase64ThrowsOnNull() throws Exception{
     54        exception.expect(DataFormatException.class);
     55        exception.expectMessage("Null data passed in");
     56        _struct.fromBase64(null);
     57    }
     58
     59    @Test
     60    public void calculateHashReturnsNull() throws Exception{
    4961        assertNull(_struct.calculateHash());
    50        
    51         error = false;
    52         try{
    53             _struct.fromByteArray(null);
    54         }catch(DataFormatException dfe){
    55             error = true;
    56         }
    57         assertTrue(error);
    5862    }
    59    
    60     public void testErrors() throws Exception{
    61         boolean error = false;
    62         try{
    63             _struct.fromByteArray(DataHelper.getASCII("water is poison"));
    64         }catch(DataFormatException dfe){
    65             error = true;
    66         }
    67         assertTrue(error);
    68        
    69         assertNull(_struct.toByteArray());
     63
     64    @Test
     65    public void fromByteArrayThrowsOnNull() throws Exception{
     66        exception.expect(DataFormatException.class);
     67        exception.expectMessage("Null data passed in");
     68        _struct.fromByteArray(null);
     69    }
     70
     71    @Test
     72    public void fromByteArrayThrowsOnError() throws Exception{
     73        exception.expect(DataFormatException.class);
     74        exception.expectMessage("Error reading the byte array");
     75        _struct.fromByteArray(DataHelper.getASCII("water is poison"));
     76    }
     77
     78    @Test
     79    public void toByteArrayReturnsNullOnError() throws Exception{
    7080        assertNull(_struct.toByteArray());
    7181    }
  • core/java/test/junit/net/i2p/data/DataTestSuite.java

    rc36905a r60efd0b  
    11package net.i2p.data;
    22
    3 import junit.framework.Test;
    4 import junit.framework.TestSuite;
     3import org.junit.runners.Suite;
     4import org.junit.runner.RunWith;
    55
     6@RunWith(Suite.class)
     7@Suite.SuiteClasses({
     8    Base64Test.class,
     9    BooleanTest.class,
     10    CertificateTest.class,
     11    DataHelperTest.class,
     12    DataStructureImplTest.class,
     13    DateTest.class,
     14    DestinationTest.class,
     15    HashTest.class,
     16    LeaseSetTest.class,
     17    LeaseTest.class,
     18    MappingTest.class,
     19    PayloadTest.class,
     20    PrivateKeyTest.class,
     21    PublicKeyTest.class,
     22    SessionKeyTest.class,
     23    SignatureTest.class,
     24    SigningPrivateKeyTest.class,
     25    SigningPublicKeyTest.class,
     26    StringTest.class,
     27    TunnelIdTest.class,
     28    UnsignedIntegerTest.class,
     29})
    630public class DataTestSuite {
    7    
    8     public static Test suite() {
    9        
    10         TestSuite suite = new TestSuite("net.i2p.data.DataTestSuite");
    11        
    12         suite.addTestSuite(Base64Test.class);
    13         suite.addTestSuite(BooleanTest.class);
    14         suite.addTestSuite(CertificateTest.class);
    15         suite.addTestSuite(DataHelperTest.class);
    16         suite.addTestSuite(DataStructureImplTest.class);
    17         suite.addTestSuite(DateTest.class);
    18         suite.addTestSuite(DestinationTest.class);
    19         suite.addTestSuite(HashTest.class);
    20         suite.addTestSuite(LeaseSetTest.class);
    21         suite.addTestSuite(LeaseTest.class);
    22         suite.addTestSuite(MappingTest.class);
    23         suite.addTestSuite(PayloadTest.class);
    24         suite.addTestSuite(PrivateKeyTest.class);
    25         suite.addTestSuite(PublicKeyTest.class);
    26         suite.addTestSuite(SessionKeyTest.class);
    27         suite.addTestSuite(SignatureTest.class);
    28         suite.addTestSuite(SigningPrivateKeyTest.class);
    29         suite.addTestSuite(SigningPublicKeyTest.class);
    30         suite.addTestSuite(StringTest.class);
    31         suite.addTestSuite(TunnelIdTest.class);
    32         suite.addTestSuite(UnsignedIntegerTest.class);
    33        
    34         return suite;
    35     }
    3631}
  • core/java/test/junit/net/i2p/data/DateTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315import java.util.Date;
    1416
    15 import junit.framework.TestCase;
     17import org.junit.Test;
    1618
    1719/**
     
    2022 * @author jrandom
    2123 */
    22 public class DateTest extends TestCase{
    23    
     24public class DateTest {
     25    @Test
    2426    public void testDate() throws Exception{
    2527        byte[] temp = null;
    26        
     28
    2729        Date orig = new Date();
    2830        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    29        
     31
    3032        DataHelper.writeDate(baos, orig);
    3133        temp = baos.toByteArray();
    32        
    33        
     34
    3435        Date d = null;
    3536        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    36        
     37
    3738        d = DataHelper.readDate(bais);
    38        
     39
    3940        assertEquals(orig, d);
    4041    }
    41    
    4242}
  • core/java/test/junit/net/i2p/data/KeyCertificateTest.java

    rc36905a r60efd0b  
    1111import static org.hamcrest.Matchers.*;
    1212import static org.junit.Assert.*;
     13
    1314import net.i2p.crypto.EncType;
    1415import net.i2p.crypto.SigType;
    15 import junit.framework.TestCase;
     16
     17import org.junit.Test;
    1618
    1719/**
    1820 * @author str4d
    1921 */
    20 public class KeyCertificateTest extends TestCase {
     22public class KeyCertificateTest {
    2123    private static final byte[] P256_PAYLOAD = new byte[] {
    2224                                    0, (byte) (SigType.ECDSA_SHA256_P256.getCode()),
     
    3032    };
    3133
     34    @Test
    3235    public void testFromP256Payload() throws DataFormatException {
    3336        KeyCertificate cert = new KeyCertificate(P256_PAYLOAD);
     
    3740    }
    3841
     42    @Test
    3943    public void testFromEd25519Payload() throws DataFormatException {
    4044        KeyCertificate cert = new KeyCertificate(P521_PAYLOAD);
  • core/java/test/junit/net/i2p/data/LeaseSetTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
     13import org.junit.Rule;
     14import org.junit.Test;
     15import org.junit.rules.ExpectedException;
    1116
    1217/**
     
    1621 */
    1722public class LeaseSetTest extends StructureTest {
     23
     24    @Rule
     25    public ExpectedException exception = ExpectedException.none();
     26
    1827    public DataStructure createDataStructure() throws DataFormatException {
    1928        LeaseSet leaseSet = new LeaseSet();
     
    2635    }
    2736    public DataStructure createStructureToRead() { return new LeaseSet(); }
    28    
    29     public void testGetLeaseInvalid() {
     37
     38    @Test
     39    public void failsToGetLeaseWhenEmpty() {
    3040        // create test subject
    3141        LeaseSet subj = new LeaseSet();
    32        
    33         // should contain no leases now..
    34         try {
    35             assertNull(subj.getLease(0));
    36         } catch(RuntimeException exc) {
    37             // all good
    38         }
    39        
     42
     43        // should contain no leases now.
     44        exception.expect(IndexOutOfBoundsException.class);
     45        exception.expectMessage("Index: 0, Size: 0");
     46        subj.getLease(0);
     47    }
     48
     49    @Test
     50    public void failsToGetInvalidLease() {
     51        // create test subject
     52        LeaseSet subj = new LeaseSet();
     53
    4054        // this shouldn't work either
    41         try {
    42             assertNull(subj.getLease(-1));
    43         } catch(RuntimeException exc) {
    44             // all good
    45         }
     55        exception.expect(IndexOutOfBoundsException.class);
     56        exception.expectMessage("-1");
     57        subj.getLease(-1);
    4658    }
    47    
     59
     60    @Test
    4861    public void testAddLeaseNull() {
    4962        // create test subject
    5063        LeaseSet subj = new LeaseSet();
    51        
     64
    5265        // now add an null lease
    53         try {
    54             subj.addLease(null);
    55             fail("Failed at failing.");
    56         } catch(IllegalArgumentException exc) {
    57             // all good
    58         }
     66        exception.expect(IllegalArgumentException.class);
     67        exception.expectMessage("erm, null lease");
     68        subj.addLease(null);
    5969    }
    60    
     70
     71    @Test
    6172    public void testAddLeaseInvalid() {
    6273        // create test subject
    6374        LeaseSet subj = new LeaseSet();
    64        
     75
    6576        // try to add completely invalid lease(ie. no data)
    66         try {
    67             subj.addLease(new Lease());
    68             fail("Failed at failing.");
    69         } catch(IllegalArgumentException exc) {
    70             // all good
    71         }
     77        exception.expect(IllegalArgumentException.class);
     78        exception.expectMessage("erm, lease has no gateway");
     79        subj.addLease(new Lease());
    7280    }
    73            
    7481}
  • core/java/test/junit/net/i2p/data/LeaseTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayOutputStream;
    1214import java.util.Date;
     15
     16import org.junit.Rule;
     17import org.junit.Test;
     18import org.junit.rules.ExpectedException;
    1319
    1420/**
     
    1824 */
    1925public class LeaseTest extends StructureTest {
     26
     27    @Rule
     28    public ExpectedException exception = ExpectedException.none();
     29
    2030    public DataStructure createDataStructure() throws DataFormatException {
    2131        Lease lease = new Lease();
     
    2535        StructureTest tst = new TunnelIdTest();
    2636        lease.setTunnelId((TunnelId)tst.createDataStructure());
    27        
     37
    2838        return lease;
    2939    }
     
    3848        StructureTest tst = new TunnelIdTest();
    3949        lease.setTunnelId((TunnelId)tst.createDataStructure());
    40        
     50
    4151        lease.getNumSuccess();
    4252        lease.getNumFailure();
     
    4454    */
    4555
     56    @Test
    4657    public void testExpiration() throws Exception{
    4758        Lease lease = new Lease();
    4859        assertTrue(lease.isExpired());
    49        
     60
    5061        lease.setEndDate(new Date(1000*60*2));
    5162        byte h[] = new byte[Hash.HASH_LENGTH];
     
    5364        StructureTest tst = new TunnelIdTest();
    5465        lease.setTunnelId((TunnelId)tst.createDataStructure());
    55        
     66
    5667        assertTrue(lease.isExpired());
    5768    }
    58    
    59     public void testNullWrite() throws Exception{
     69
     70    @Test
     71    public void failsWriteWithNullTunnelId() throws Exception{
    6072        Lease lease = new Lease();
    6173        lease.setEndDate(new Date(1000*60*2));
     
    6375        lease.setGateway(new Hash(h));
    6476        lease.setTunnelId(null);
    65         boolean error = false;
    66         try{
    67             lease.writeBytes(new ByteArrayOutputStream());
    68         }catch(DataFormatException dfe){
    69             error = true;
    70         }
    71         assertTrue(error);
    72        
    73         lease = new Lease();
     77
     78        exception.expect(DataFormatException.class);
     79        exception.expectMessage("Not enough data to write out a Lease");
     80        lease.writeBytes(new ByteArrayOutputStream());
     81    }
     82
     83    @Test
     84    public void failsWriteWithNullGateway() throws Exception{
     85        Lease lease = new Lease();
    7486        lease.setEndDate(new Date(1000*60*2));
    75         h = new byte[Hash.HASH_LENGTH];
     87        byte h[] = new byte[Hash.HASH_LENGTH];
    7688        lease.setGateway(null);
    7789        StructureTest tst = new TunnelIdTest();
    7890        lease.setTunnelId((TunnelId)tst.createDataStructure());
    79         error = false;
    80         try{
    81             lease.writeBytes(new ByteArrayOutputStream());
    82         }catch(DataFormatException dfe){
    83             error = true;
    84         }
    85         assertTrue(error);
     91
     92        exception.expect(DataFormatException.class);
     93        exception.expectMessage("Not enough data to write out a Lease");
     94        lease.writeBytes(new ByteArrayOutputStream());
    8695    }
    87    
     96
     97    @Test
    8898    public void testNullEquals() throws Exception{
    8999        Lease lease = new Lease();
     
    94104        assertFalse(lease.equals(null));
    95105    }
    96    
    97106}
  • core/java/test/junit/net/i2p/data/MappingTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315import java.util.Properties;
    1416
    15 import junit.framework.TestCase;
     17import org.junit.Test;
    1618
    1719/**
     
    2022 * @author jrandom
    2123 */
    22 public class MappingTest extends TestCase{
    23    
     24public class MappingTest {
     25    @Test
    2426    public void testProperties() throws Exception{
    2527        byte[] temp = null;
    26        
     28
    2729        Properties orig = new Properties();
    2830        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     
    3032        orig.setProperty("key2", "val2");
    3133        orig.setProperty("key3", "val3");
    32        
     34
    3335        DataHelper.writeProperties(baos, orig);
    3436        temp = baos.toByteArray();
    35        
    36        
     37
    3738        Properties p = null;
    3839        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    39        
     40
    4041        p = DataHelper.readProperties(bais);
    41        
     42
    4243        assertEquals(orig, p);
    4344    }
    44    
    4545}
  • core/java/test/junit/net/i2p/data/PrivateKeyTest.java

    rc36905a r60efd0b  
    99 */
    1010 
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
     15
     16import org.junit.Rule;
     17import org.junit.Test;
     18import org.junit.rules.ExpectedException;
    1319
    1420/**
     
    1824 */
    1925public class PrivateKeyTest extends StructureTest {
     26
     27    @Rule
     28    public ExpectedException exception = ExpectedException.none();
     29
    2030    public DataStructure createDataStructure() throws DataFormatException {
    2131        PrivateKey privateKey = new PrivateKey();
     
    2737    }
    2838    public DataStructure createStructureToRead() { return new PrivateKey(); }
    29    
     39
     40    @Test
    3041    public void testBase64Constructor() throws Exception{
    3142        PrivateKey privateKey = new PrivateKey();
     
    3445            data[i] = (byte)(i%56);
    3546        privateKey.setData(data);
    36        
     47
    3748        PrivateKey key2 = new PrivateKey(privateKey.toBase64());
    3849        assertEquals(privateKey, key2);
    3950    }
    40    
     51
     52    @Test
    4153    public void testNullEquals(){
    4254        PrivateKey privateKey = new PrivateKey();
     
    4557            data[i] = (byte)(i%56);
    4658        privateKey.setData(data);
    47        
     59
    4860        assertFalse(privateKey.equals(null));
    4961    }
    50    
     62
     63    @Test
    5164    public void testNullData() throws Exception{
    5265        PrivateKey privateKey = new PrivateKey();
    5366        privateKey.toString();
    54        
    55         boolean error = false;
    56         try{
    57             privateKey.writeBytes(new ByteArrayOutputStream());
    58         }catch(DataFormatException dfe){
    59             error = true;
    60         }
    61         assertTrue(error);
     67
     68        exception.expect(DataFormatException.class);
     69        exception.expectMessage("No data to write out");
     70        privateKey.writeBytes(new ByteArrayOutputStream());
    6271    }
    63    
     72
     73    @Test
    6474    public void testShortData() throws Exception{
    6575        PrivateKey privateKey = new PrivateKey();
     
    6777        for (int i = 0; i < data.length; i++)
    6878            data[i] = (byte)(i);
    69        
    70         boolean error = false;
    71         try{
    72             privateKey.setData(data);
    73             privateKey.writeBytes(new ByteArrayOutputStream());
    74         }catch(DataFormatException dfe){
    75             error = true;
    76         }catch(IllegalArgumentException exc) {
    77             error = true;
    78         }
    79         assertTrue(error);
     79
     80        exception.expect(IllegalArgumentException.class);
     81        exception.expectMessage("Bad data length: 56; required: " + PrivateKey.KEYSIZE_BYTES);
     82        privateKey.setData(data);
    8083    }
    81    
     84
     85    @Test
    8286    public void testShortRead() throws Exception{
    8387        PrivateKey privateKey = new PrivateKey();
    8488        ByteArrayInputStream in = new ByteArrayInputStream(DataHelper.getASCII("six times nine equals forty-two"));
    85         boolean error = false;
    86         try{
    87             privateKey.readBytes(in);
    88         }catch(DataFormatException dfe){
    89             error = true;
    90         }
    91         assertTrue(error);
     89
     90        exception.expect(DataFormatException.class);
     91        exception.expectMessage("EOF reading PrivateKey, read: 31, required: " + PrivateKey.KEYSIZE_BYTES);
     92        privateKey.readBytes(in);
    9293    }
    93    
    9494}
  • core/java/test/junit/net/i2p/data/PublicKeyTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
     15
     16import org.junit.Rule;
     17import org.junit.Test;
     18import org.junit.rules.ExpectedException;
    1319
    1420/**
     
    1824 */
    1925public class PublicKeyTest extends StructureTest {
     26
     27    @Rule
     28    public ExpectedException exception = ExpectedException.none();
     29
    2030    public DataStructure createDataStructure() throws DataFormatException {
    2131        PublicKey publicKey = new PublicKey();
     
    2737    }
    2838    public DataStructure createStructureToRead() { return new PublicKey(); }
    29    
     39
     40    @Test
    3041    public void testBase64Constructor() throws Exception{
    3142        PublicKey publicKey = new PublicKey();
     
    3445            data[i] = (byte)(i%56);
    3546        publicKey.setData(data);
    36        
     47
    3748        PublicKey key2 = new PublicKey(publicKey.toBase64());
    3849        assertEquals(publicKey, key2);
    3950    }
    40    
     51
     52    @Test
    4153    public void testNullEquals(){
    4254        PublicKey publicKey = new PublicKey();
     
    4557            data[i] = (byte)(i%56);
    4658        publicKey.setData(data);
    47        
     59
    4860        assertFalse(publicKey.equals(null));
    4961    }
    50    
     62
     63    @Test
    5164    public void testNullData() throws Exception{
    5265        PublicKey publicKey = new PublicKey();
    5366        publicKey.toString();
    54        
    55         boolean error = false;
    56         try{
    57             publicKey.writeBytes(new ByteArrayOutputStream());
    58         }catch(DataFormatException dfe){
    59             error = true;
    60         }
    61         assertTrue(error);
     67
     68        exception.expect(DataFormatException.class);
     69        exception.expectMessage("No data to write out");
     70        publicKey.writeBytes(new ByteArrayOutputStream());
    6271    }
    63    
     72
     73    @Test
    6474    public void testShortData() throws Exception{
    6575        PublicKey publicKey = new PublicKey();
     
    6777        for (int i = 0; i < data.length; i++)
    6878            data[i] = (byte)(i);
    69        
    70         boolean error = false;
    71         try{
    72             publicKey.setData(data);
    73             publicKey.writeBytes(new ByteArrayOutputStream());
    74         }catch(DataFormatException dfe){
    75             error = true;
    76         }catch(IllegalArgumentException exc) {
    77             error = true;
    78         }
    79         assertTrue(error);
     79
     80        exception.expect(IllegalArgumentException.class);
     81        exception.expectMessage("Bad data length: 56; required: " + PublicKey.KEYSIZE_BYTES);
     82        publicKey.setData(data);
     83        publicKey.writeBytes(new ByteArrayOutputStream());
    8084    }
    81    
     85
     86    @Test
    8287    public void testShortRead() throws Exception{
    8388        PublicKey publicKey = new PublicKey();
    8489        ByteArrayInputStream in = new ByteArrayInputStream(DataHelper.getASCII("six times nine equals forty-two"));
    85         boolean error = false;
    86         try{
    87             publicKey.readBytes(in);
    88         }catch(DataFormatException dfe){
    89             error = true;
    90         }
    91         assertTrue(error);
     90
     91        exception.expect(DataFormatException.class);
     92        exception.expectMessage("EOF reading PublicKey, read: 31, required: " + PublicKey.KEYSIZE_BYTES);
     93        publicKey.readBytes(in);
    9294    }
    9395}
  • core/java/test/junit/net/i2p/data/SigningPrivateKeyTest.java

    rc36905a r60efd0b  
    99 */
    1010 
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
     15
     16import org.junit.Rule;
     17import org.junit.Test;
     18import org.junit.rules.ExpectedException;
    1319
    1420/**
     
    1824 */
    1925public class SigningPrivateKeyTest extends StructureTest {
     26
     27    @Rule
     28    public ExpectedException exception = ExpectedException.none();
     29
    2030    public DataStructure createDataStructure() throws DataFormatException {
    2131        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
     
    2737    }
    2838    public DataStructure createStructureToRead() { return new SigningPrivateKey(); }
    29    
     39
     40    @Test
    3041    public void testBase64Constructor() throws Exception{
    3142        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
     
    3445            data[i] = (byte)(i%56);
    3546        signingPrivateKey.setData(data);
    36        
     47
    3748        SigningPrivateKey key2 = new SigningPrivateKey(signingPrivateKey.toBase64());
    3849        assertEquals(signingPrivateKey, key2);
    3950    }
    40    
     51
     52    @Test
    4153    public void testNullEquals(){
    4254        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
     
    4557            data[i] = (byte)(i%56);
    4658        signingPrivateKey.setData(data);
    47        
     59
    4860        assertFalse(signingPrivateKey.equals(null));
    4961    }
    50    
     62
     63    @Test
    5164    public void testNullData() throws Exception{
    5265        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
    5366        signingPrivateKey.toString();
    54        
    55         boolean error = false;
    56         try{
    57             signingPrivateKey.writeBytes(new ByteArrayOutputStream());
    58         }catch(DataFormatException dfe){
    59             error = true;
    60         }
    61         assertTrue(error);
     67
     68        exception.expect(DataFormatException.class);
     69        exception.expectMessage("No data to write out");
     70        signingPrivateKey.writeBytes(new ByteArrayOutputStream());
    6271    }
    63    
     72
     73    @Test
    6474    public void testShortData() throws Exception{
    6575        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
     
    6777        for (int i = 0; i < data.length; i++)
    6878            data[i] = (byte)(i);
    69        
    70         boolean error = false;
    71         try{
    72             signingPrivateKey.setData(data);
    73             signingPrivateKey.writeBytes(new ByteArrayOutputStream());
    74         }catch(DataFormatException dfe){
    75             error = true;
    76         }catch(IllegalArgumentException exc) {
    77             error = true;
    78         }
    79         assertTrue(error);
     79
     80        exception.expect(IllegalArgumentException.class);
     81        exception.expectMessage("Bad data length: 56; required: " + SigningPrivateKey.KEYSIZE_BYTES);
     82        signingPrivateKey.setData(data);
     83        signingPrivateKey.writeBytes(new ByteArrayOutputStream());
    8084    }
    81    
     85
     86    @Test
    8287    public void testShortRead() throws Exception{
    8388        SigningPrivateKey signingPrivateKey = new SigningPrivateKey();
    8489        ByteArrayInputStream in = new ByteArrayInputStream(DataHelper.getASCII("short"));
    85         boolean error = false;
    86         try{
    87             signingPrivateKey.readBytes(in);
    88         }catch(DataFormatException dfe){
    89             error = true;
    90         }
    91         assertTrue(error);
     90
     91        exception.expect(DataFormatException.class);
     92        exception.expectMessage("EOF reading SigningPrivateKey, read: 5, required: " + SigningPrivateKey.KEYSIZE_BYTES);
     93        signingPrivateKey.readBytes(in);
    9294    }
    93    
    94    
    9595}
  • core/java/test/junit/net/i2p/data/SigningPublicKeyTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
     15
     16import org.junit.Rule;
     17import org.junit.Test;
     18import org.junit.rules.ExpectedException;
    1319
    1420/**
     
    1824 */
    1925public class SigningPublicKeyTest extends StructureTest {
     26
     27    @Rule
     28    public ExpectedException exception = ExpectedException.none();
     29
    2030    public DataStructure createDataStructure() throws DataFormatException {
    2131        SigningPublicKey publicKey = new SigningPublicKey();
     
    2737    }
    2838    public DataStructure createStructureToRead() { return new SigningPublicKey(); }
    29    
     39
     40    @Test
    3041    public void testBase64Constructor() throws Exception{
    3142        SigningPublicKey publicKey = new SigningPublicKey();
     
    3445            data[i] = (byte)(i%56);
    3546        publicKey.setData(data);
    36        
     47
    3748        SigningPublicKey key2 = new SigningPublicKey(publicKey.toBase64());
    3849        assertEquals(publicKey, key2);
    3950    }
    40    
     51
     52    @Test
    4153    public void testNullEquals(){
    4254        SigningPublicKey publicKey = new SigningPublicKey();
     
    4557            data[i] = (byte)(i%56);
    4658        publicKey.setData(data);
    47        
     59
    4860        assertFalse(publicKey.equals(null));
    4961    }
    50    
     62
     63    @Test
    5164    public void testNullData() throws Exception{
    5265        SigningPublicKey publicKey = new SigningPublicKey();
    5366        publicKey.toString();
    54        
    55         boolean error = false;
    56         try{
    57             publicKey.writeBytes(new ByteArrayOutputStream());
    58         }catch(DataFormatException dfe){
    59             error = true;
    60         }
    61         assertTrue(error);
     67
     68        exception.expect(DataFormatException.class);
     69        exception.expectMessage("No data to write out");
     70        publicKey.writeBytes(new ByteArrayOutputStream());
    6271    }
    63    
     72
     73    @Test
    6474    public void testShortData() throws Exception{
    6575        SigningPublicKey publicKey = new SigningPublicKey();
     
    6777        for (int i = 0; i < data.length; i++)
    6878            data[i] = (byte)(i);
    69        
    70         boolean error = false;
    71         try{
    72             publicKey.setData(data);
    73             publicKey.writeBytes(new ByteArrayOutputStream());
    74         }catch(DataFormatException dfe){
    75             error = true;
    76         }catch(IllegalArgumentException exc) {
    77             error = true;
    78         }
    79        
    80         assertTrue(error);
     79
     80        exception.expect(IllegalArgumentException.class);
     81        exception.expectMessage("Bad data length: 56; required: " + SigningPublicKey.KEYSIZE_BYTES);
     82        publicKey.setData(data);
     83        publicKey.writeBytes(new ByteArrayOutputStream());
    8184    }
    82    
     85
     86    @Test
    8387    public void testShortRead() throws Exception{
    8488        SigningPublicKey publicKey = new SigningPublicKey();
    8589        ByteArrayInputStream in = new ByteArrayInputStream(DataHelper.getASCII("six times nine equals forty-two"));
    86         boolean error = false;
    87         try{
    88             publicKey.readBytes(in);
    89         }catch(DataFormatException dfe){
    90             error = true;
    91         }
    92         assertTrue(error);
     90
     91        exception.expect(DataFormatException.class);
     92        exception.expectMessage("EOF reading SigningPublicKey, read: 31, required: " + SigningPublicKey.KEYSIZE_BYTES);
     93        publicKey.readBytes(in);
    9394    }
    94        
    9595}
  • core/java/test/junit/net/i2p/data/SimpleDataStructureTest.java

    rc36905a r60efd0b  
    99 */
    1010
    11 import junit.framework.TestCase;
     11import static org.junit.Assert.*;
     12
     13import org.junit.Rule;
     14import org.junit.Test;
     15import org.junit.rules.ExpectedException;
    1216
    1317/**
     
    1620 * @author welterde
    1721 */
    18 public class SimpleDataStructureTest extends TestCase {
    19    
    20     public void testSetDataImmutable() throws Exception {
     22public class SimpleDataStructureTest {
     23
     24    @Rule
     25    public ExpectedException exception = ExpectedException.none();
     26
     27    @Test
     28    public void setDataThrowsOnNullAfterDataSet() throws Exception {
    2129        // create new test subject
    2230        TestStruct struct = new TestStruct();
    23        
     31
    2432        // try to set null object.. should not fail..
    2533        struct.setData(null);
    26        
     34
    2735        // set data to something
    2836        struct.setData(new byte[3]);
    29        
     37
    3038        // now setting it to null should fail
    31         try {
    32             struct.setData(null);
    33             fail("Should not have allowed us to change this..");
    34         } catch(RuntimeException exc) {
    35             // all good
    36         }
    37        
    38         // setting it to something non-null should fail as well.
    39         try {
    40             struct.setData(new byte[3]);
    41             fail("Should not have allowed us to change this..");
    42         } catch(RuntimeException exc) {
    43             // all good
    44         }
     39        exception.expect(RuntimeException.class);
     40        exception.expectMessage("Data already set");
     41        struct.setData(null);
    4542    }
    46    
     43
     44    @Test
     45    public void setDataThrowsOnDataAfterDataSet() throws Exception {
     46        // create new test subject
     47        TestStruct struct = new TestStruct();
     48
     49        // try to set null object.. should not fail..
     50        struct.setData(null);
     51
     52        // set data to something
     53        struct.setData(new byte[3]);
     54
     55        // setting it to something non-null should fail.
     56        exception.expect(RuntimeException.class);
     57        exception.expectMessage("Data already set");
     58        struct.setData(new byte[3]);
     59    }
     60
     61    @Test
    4762    public void testReadBytesImmutable() throws Exception {
    4863        // create new test subject
    4964        TestStruct struct = new TestStruct();
    50        
     65
    5166        // load some data using setData
    5267        struct.setData(new byte[3]);
    53        
     68
    5469        // now try to load via readBytes
    5570        try {
     
    6075        }
    6176    }
    62    
     77
     78    @Test
    6379    public void testToBase64Safe() throws Exception {
    6480        // create new test subject
    6581        TestStruct struct = new TestStruct();
    66        
     82
    6783        // now try to get the Base64.. should not throw an exception, but should not be an empty string either
    6884        assertNull(struct.toBase64());
    6985    }
    7086
     87    @Test
    7188    public void testCalculateHashSafe() throws Exception {
    7289        // create new test subject
    7390        TestStruct struct = new TestStruct();
    74        
     91
    7592        // now try to get the hash.. should not throw an exception
    7693        assertNull(struct.calculateHash());
    7794    }
    78    
     95
     96    @Test
    7997    public void testHashCodeSafe() throws Exception {
    8098        // create new test subject
    8199        TestStruct struct = new TestStruct();
    82        
     100
    83101        // just make sure it doesn't explode in our face
    84102        struct.hashCode();
    85103    }
    86    
     104
    87105    public class TestStruct extends SimpleDataStructure {
    88106        public int length() {
     
    90108        }
    91109    }
    92    
    93110}
  • core/java/test/junit/net/i2p/data/StringTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315
    14 import junit.framework.TestCase;
     16import org.junit.Test;
    1517
    1618/**
     
    1921 * @author jrandom
    2022 */
    21 public class StringTest extends TestCase{
    22    
     23public class StringTest {
     24    @Test
    2325    public void testString() throws Exception{
    2426        byte[] temp = null;
    25        
     27
    2628        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    27        
     29
    2830        DataHelper.writeString(baos, "Hello, I2P");
    2931        temp = baos.toByteArray();
    30        
    31        
     32
     33
    3234        String s = null;
    3335        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    34        
     36
    3537        s = DataHelper.readString(bais);
    36        
     38
    3739        assertEquals(s, "Hello, I2P");
    3840    }
    39    
     41
    4042}
  • core/java/test/junit/net/i2p/data/StructureTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315
    14 import junit.framework.TestCase;
     16import org.junit.Test;
    1517
    1618/**
     
    2022 */
    2123
    22 public abstract class StructureTest extends TestCase{
    23    
     24public abstract class StructureTest {
     25
    2426    /** create a populated structure for writing */
    2527    public abstract DataStructure createDataStructure() throws DataFormatException;
     
    2729    /** create an unpopulated structure for reading */
    2830    public abstract DataStructure createStructureToRead();
    29    
     31
     32    @Test
    3033    public void testStructure() throws Exception{
    3134        byte[] temp = null;
    32        
     35
    3336        DataStructure orig;
    3437        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    35        
     38
    3639        orig = createDataStructure();
    3740        orig.writeBytes(baos);
    38        
    39        
     41
     42
    4043        temp = baos.toByteArray();
    41        
     44
    4245        DataStructure ds;
    4346        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    44        
     47
    4548        ds = createStructureToRead();
    4649        ds.readBytes(bais);
    47        
     50
    4851
    4952        // I2CP message classes don't implement equals()
     
    5760        assert(DataHelper.eq(temp, temp2));
    5861    }
    59    
    6062}
  • core/java/test/junit/net/i2p/data/UnsignedIntegerTest.java

    rc36905a r60efd0b  
    99 */
    1010
     11import static org.junit.Assert.*;
     12
    1113import java.io.ByteArrayInputStream;
    1214import java.io.ByteArrayOutputStream;
    1315
    14 import junit.framework.TestCase;
     16import org.junit.Test;
    1517
    1618/**
     
    1921 * @author jrandom
    2022 */
    21 public class UnsignedIntegerTest extends TestCase{
    22    
     23public class UnsignedIntegerTest {
     24    @Test
    2325    public void testLong() throws Exception{
    2426        byte[] temp = null;
    25        
     27
    2628        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    27        
     29
    2830        DataHelper.writeLong(baos, 4, 42);
    2931        temp = baos.toByteArray();
    30        
    31        
     32
    3233        long l;
    3334        ByteArrayInputStream bais = new ByteArrayInputStream(temp);
    34        
     35
    3536        l = DataHelper.readLong(bais, 4);
    36        
     37
    3738        assertEquals(42, l);
    3839    }
  • core/java/test/junit/net/i2p/data/i2cp/I2CPTestSuite.java

    rc36905a r60efd0b  
    11package net.i2p.data.i2cp;
    22
    3 import junit.framework.Test;
    4 import junit.framework.TestSuite;
     3import org.junit.runners.Suite;
     4import org.junit.runner.RunWith;
    55
     6@RunWith(Suite.class)
     7@Suite.SuiteClasses({
     8    AbuseReasonTest.class,
     9    AbuseSeverityTest.class,
     10    BandwidthLimitsMessageTest.class,
     11    CreateLeaseSetMessageTest.class,
     12    CreateSessionMessageTest.class,
     13    DestLookupMessageTest.class,
     14    DestReplyMessageTest.class,
     15    DestroySessionMessageTest.class,
     16    DisconnectMessageTest.class,
     17    GetBandwidthLimitsMessageTest.class,
     18    GetDateMessageTest.class,
     19    MessageIdTest.class,
     20    MessagePayloadMessageTest.class,
     21    MessageStatusMessageTest.class,
     22    ReceiveMessageBeginMessageTest.class,
     23    ReceiveMessageEndMessageTest.class,
     24    ReconfigureSessionMessageTest.class,
     25    ReportAbuseMessageTest.class,
     26    RequestLeaseSetMessageTest.class,
     27    SendMessageExpiresMessageTest.class,
     28    SendMessageMessageTest.class,
     29    SessionConfigTest.class,
     30    SessionIdTest.class,
     31    SessionStatusMessageTest.class,
     32    SetDateMessageTest.class,
     33})
    634public class I2CPTestSuite {
    7    
    8     public static Test suite() {
    9        
    10         TestSuite suite = new TestSuite("net.i2p.data.i2cp.I2CPTestSuite");
    11        
    12         suite.addTestSuite(AbuseReasonTest.class);
    13         suite.addTestSuite(AbuseSeverityTest.class);
    14         suite.addTestSuite(BandwidthLimitsMessageTest.class);
    15         suite.addTestSuite(CreateLeaseSetMessageTest.class);
    16         suite.addTestSuite(CreateSessionMessageTest.class);
    17         suite.addTestSuite(DestLookupMessageTest.class);
    18         suite.addTestSuite(DestReplyMessageTest.class);
    19         suite.addTestSuite(DestroySessionMessageTest.class);
    20         suite.addTestSuite(DisconnectMessageTest.class);
    21         suite.addTestSuite(GetBandwidthLimitsMessageTest.class);
    22         suite.addTestSuite(GetDateMessageTest.class);
    23         suite.addTestSuite(MessageIdTest.class);
    24         suite.addTestSuite(MessagePayloadMessageTest.class);
    25         suite.addTestSuite(MessageStatusMessageTest.class);
    26         suite.addTestSuite(ReceiveMessageBeginMessageTest.class);
    27         suite.addTestSuite(ReceiveMessageEndMessageTest.class);
    28         suite.addTestSuite(ReconfigureSessionMessageTest.class);
    29         suite.addTestSuite(ReportAbuseMessageTest.class);
    30         suite.addTestSuite(RequestLeaseSetMessageTest.class);
    31         suite.addTestSuite(SendMessageExpiresMessageTest.class);
    32         suite.addTestSuite(SendMessageMessageTest.class);
    33         suite.addTestSuite(SessionConfigTest.class);
    34         suite.addTestSuite(SessionIdTest.class);
    35         suite.addTestSuite(SessionStatusMessageTest.class);
    36         suite.addTestSuite(SetDateMessageTest.class);
    37        
    38         return suite;
    39     }
    4035}
Note: See TracChangeset for help on using the changeset viewer.