com.idevicesinc.sweetblue

Class AbstractTestClass

java.lang.Object

com.idevicesinc.sweetblue.AbstractTestClass

public abstract class AbstractTestClass
extends java.lang.Object

Base class to help in writing unit tests. You do not need to use this class, it's provided for convenience (and we use it to test the core library). This class allows you to easily test asynchronous operations (but you can also do syncrhonous tests with it). You should make sure to call the assert methods baked into this class when running asynchronous tests, otherwise if a test fails, it will keep spinning forever -- because when you call startAsyncTest(), we acquire a Semaphore, which locks the thread. You must also remember to call succeed(), again when calling startAsyncTest() to release the semaphore.

See Also:

startAsyncTest(), startSynchronousTest(), succeed()

Constructor Summary

Constructors

Constructor and Description
AbstractTestClass()

Method Summary

Modifier and Type	Method and Description
void	assertArrayEquals(byte[] expected, byte[] actual) Forwards Assert.assertArrayEquals(byte[], byte[]), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertArrayEquals(java.lang.String msg, byte[] expected, byte[] actual) Forwards Assert.assertArrayEquals(String, byte[], byte[]), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(double expected, double actual, double delta) Forwards Assert.assertEquals(double, double, double), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(long expected, long actual) Forwards Assert.assertEquals(long, long), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(java.lang.String failMsg, double expected, double actual, double delta) Forwards Assert.assertEquals(String, double, double, double), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(java.lang.String failMsg, long expected, long actual) Forwards Assert.assertEquals(String, long, long), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(java.lang.String expected, java.lang.String actual) Forwards Assert.assertEquals(Object, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertEquals(java.lang.String failMsg, java.lang.String expected, java.lang.String actual) Forwards Assert.assertEquals(String, Object, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertFalse(boolean condition) Forwards Assert.assertFalse(boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertFalse(java.lang.String msg, boolean condition) Forwards Assert.assertFalse(String, boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertNotNull(java.lang.Object object) Forwards Assert.assertNotNull(Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertNotNull(java.lang.String msg, java.lang.Object object) Forwards Assert.assertNotNull(String, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertNull(java.lang.Object object) Forwards Assert.assertNull(Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertNull(java.lang.String msg, java.lang.Object object) Forwards Assert.assertNull(String, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
<T> void	assertThat(java.lang.String failMessage, T actual, org.hamcrest.Matcher<? super T> matcher) Forwards Assert.assertThat(String, Object, Matcher), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
<T> void	assertThat(T actual, org.hamcrest.Matcher<? super T> matcher) Forwards Assert.assertThat(Object, Matcher), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertTrue(boolean condition) Forwards Assert.assertTrue(boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	assertTrue(java.lang.String msg, boolean condition) Forwards Assert.assertTrue(String, boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).
void	reacquire() This will re-acquire the semaphore to lock the current thread.
void	release() Releases the semaphore, if it's being held.
void	startAsyncTest() Call this method if the test is asynchronous.
void	startSynchronousTest() Call this method if the test is synchronous.
void	succeed() Releases the semphore held by this class (if applicable), and prints a message to the console about the test completing successfully.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractTestClass

public AbstractTestClass()

Method Detail

startSynchronousTest

public void startSynchronousTest()
                          throws java.lang.Exception

Call this method if the test is synchronous. This should be the first method called in the test method. You should also call succeed() when the test is done, but it's not necessary for the test to complete.

Throws:

java.lang.Exception

startAsyncTest

public void startAsyncTest()
                    throws java.lang.Exception

Call this method if the test is asynchronous. This should be the last method in the test method, as it acquires a Semaphore. You then need to call succeed() to, well, succeed the test. Otherwise, you should be using any of the assert methods in this class to catch errors (and will throw exceptions if there are -- and properly kill the test if this is the case)

Throws:

java.lang.Exception

reacquire

public void reacquire()
               throws java.lang.Exception

This will re-acquire the semaphore to lock the current thread. In most cases, you shouldn't need to use this, but it's here for flexibility.

Throws:

java.lang.Exception

release

public void release()

Releases the semaphore, if it's being held. You should not call this directly, but instead use succeed(), unless you are doing something that requires re-aquiring the semaphore.

succeed

public void succeed()

Releases the semphore held by this class (if applicable), and prints a message to the console about the test completing successfully.

assertTrue

public void assertTrue(boolean condition)

Forwards Assert.assertTrue(boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertTrue

public void assertTrue(java.lang.String msg,
                       boolean condition)

Forwards Assert.assertTrue(String, boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertFalse

public void assertFalse(boolean condition)

Forwards Assert.assertFalse(boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertFalse

public void assertFalse(java.lang.String msg,
                        boolean condition)

Forwards Assert.assertFalse(String, boolean), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertNotNull

public void assertNotNull(java.lang.Object object)

Forwards Assert.assertNotNull(Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertNotNull

public void assertNotNull(java.lang.String msg,
                          java.lang.Object object)

Forwards Assert.assertNotNull(String, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertNull

public void assertNull(java.lang.Object object)

Forwards Assert.assertNull(Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertNull

public void assertNull(java.lang.String msg,
                       java.lang.Object object)

Forwards Assert.assertNull(String, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(long expected,
                         long actual)

Forwards Assert.assertEquals(long, long), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(java.lang.String failMsg,
                         long expected,
                         long actual)

Forwards Assert.assertEquals(String, long, long), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(double expected,
                         double actual,
                         double delta)

Forwards Assert.assertEquals(double, double, double), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(java.lang.String failMsg,
                         double expected,
                         double actual,
                         double delta)

Forwards Assert.assertEquals(String, double, double, double), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(java.lang.String expected,
                         java.lang.String actual)

Forwards Assert.assertEquals(Object, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertEquals

public void assertEquals(java.lang.String failMsg,
                         java.lang.String expected,
                         java.lang.String actual)

Forwards Assert.assertEquals(String, Object, Object), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertArrayEquals

public void assertArrayEquals(byte[] expected,
                              byte[] actual)

Forwards Assert.assertArrayEquals(byte[], byte[]), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertArrayEquals

public void assertArrayEquals(java.lang.String msg,
                              byte[] expected,
                              byte[] actual)

Forwards Assert.assertArrayEquals(String, byte[], byte[]), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertThat

public <T> void assertThat(T actual,
                           org.hamcrest.Matcher<? super T> matcher)

Forwards Assert.assertThat(Object, Matcher), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).

assertThat

public <T> void assertThat(java.lang.String failMessage,
                           T actual,
                           org.hamcrest.Matcher<? super T> matcher)

Forwards Assert.assertThat(String, Object, Matcher), and wraps it in a try/catch so that we can properly release the semaphore when a test fails (so it doesn't lock up).