diff --git a/tests/UglyQueue/UglyQueueTest.php b/tests/UglyQueue/UglyQueueTest.php
index e23bce6..f2eccf3 100644
--- a/tests/UglyQueue/UglyQueueTest.php
+++ b/tests/UglyQueue/UglyQueueTest.php
@@ -7,7 +7,7 @@ require_once __DIR__.'/../misc/cleanup.php';
 /**
  * Class UglyQueueTest
  */
-class UglyQueueTest extends PHPUnit_Framework_TestCase
+class UglyQueueTest extends PHPUnit\Framework\TestCase
 {
     protected $baseDir;
 
@@ -28,45 +28,44 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
         '10' => 'Virginia baked ham, sliced',
     );
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->baseDir = realpath(__DIR__.'/../misc/queues');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::__construct
-     * @uses \DCarbone\UglyQueue
-     * @return \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::__construct
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueue
      */
     public function testCanInitializeObjectWithValidParameters()
     {
-        $uglyQueue = new \DCarbone\UglyQueue($this->baseDir, 'tasty-sandwich');
+        $uglyQueue = new \Cybercinch\UglyQueue($this->baseDir, 'tasty-sandwich');
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::retrieveItems
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToProcessQueueAfterInitializationBeforeLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToProcessQueueAfterInitializationBeforeLock(\Cybercinch\UglyQueue $uglyQueue)
     {
-        
+        $this->expectException(\RuntimeException::class);
         $uglyQueue->retrieveItems();
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::keyExistsInQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::keyExistsInQueue
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testKeyExistsInQueueReturnsFalseWithEmptyQueueAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testKeyExistsInQueueReturnsFalseWithEmptyQueueAfterInitialization(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $exists = $uglyQueue->keyExistsInQueue(0);
@@ -75,24 +74,24 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::addItem
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::addItem
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToAddItemsToQueueWithoutLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToAddItemsToQueueWithoutLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        $this->expectException(\RuntimeException::class);
         $uglyQueue->addItem('test', 'value');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getPath
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::getPath
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueDirectory(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueDirectory(\Cybercinch\UglyQueue $uglyQueue)
     {
         $queuePath = $uglyQueue->getPath();
 
@@ -100,12 +99,12 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getName
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::getName
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueName(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueName(\Cybercinch\UglyQueue $uglyQueue)
     {
         $queueName = $uglyQueue->getName();
 
@@ -113,33 +112,33 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getMode
+     * @covers \Cybercinch\UglyQueue::getMode
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueMode(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueMode(\Cybercinch\UglyQueue $uglyQueue)
     {
         $mode = $uglyQueue->getMode();
-        $this->assertEquals(\DCarbone\UglyQueue::QUEUE_READWRITE, $mode);
+        $this->assertEquals(\Cybercinch\UglyQueue::QUEUE_READWRITE, $mode);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getBaseDir
+     * @covers \Cybercinch\UglyQueue::getBaseDir
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetBaseDirectory(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetBaseDirectory(\Cybercinch\UglyQueue $uglyQueue)
     {
         $baseDir = $uglyQueue->getBaseDir();
         $this->assertEquals($this->baseDir, $baseDir);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getLockFile
+     * @covers \Cybercinch\UglyQueue::getLockFile
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetLockFilePath(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetLockFilePath(\Cybercinch\UglyQueue $uglyQueue)
     {
         $lockFile = $uglyQueue->getLockFile();
         $this->assertEquals(
@@ -153,11 +152,11 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueFile
+     * @covers \Cybercinch\UglyQueue::getQueueFile
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueFilePath(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueFilePath(\Cybercinch\UglyQueue $uglyQueue)
     {
         $queueFile = $uglyQueue->getQueueFile();
         $this->assertEquals(
@@ -171,11 +170,11 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueTmpFile
+     * @covers \Cybercinch\UglyQueue::getQueueTmpFile
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueTmpFilePath(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueTmpFilePath(\Cybercinch\UglyQueue $uglyQueue)
     {
         $queueTmpFile = $uglyQueue->getQueueTmpFile();
         $this->assertEquals(
@@ -190,11 +189,11 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getSerializeFile
+     * @covers \Cybercinch\UglyQueue::getSerializeFile
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetSerializeFilePath(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetSerializeFilePath(\Cybercinch\UglyQueue $uglyQueue)
     {
         $serializeFile = $uglyQueue->getSerializeFile();
         $this->assertEquals(
@@ -209,77 +208,77 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueLockedStatus(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueLockedStatus(\Cybercinch\UglyQueue $uglyQueue)
     {
         $locked = $uglyQueue->isAlreadyLocked();
         $this->assertFalse($locked);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::count
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testGetQueueItemCountReturnsZeroWithEmptyQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testGetQueueItemCountReturnsZeroWithEmptyQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
         $itemCount = count($uglyQueue);
         $this->assertEquals(0, $itemCount);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::__construct
-     * @uses \DCarbone\UglyQueue
-     * @return \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::__construct
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueue
      */
     public function testCanInitializeExistingQueue()
     {
-        $uglyQueue = new \DCarbone\UglyQueue($this->baseDir, 'tasty-sandwich');
+        $uglyQueue = new \Cybercinch\UglyQueue($this->baseDir, 'tasty-sandwich');
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenPassingNonIntegerValueToLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenPassingNonIntegerValueToLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->lock('7 billion');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenPassingNegativeIntegerValueToLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenPassingNegativeIntegerValueToLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->lock(-73);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @covers \DCarbone\UglyQueue::createLockFile
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @covers \Cybercinch\UglyQueue::createLockFile
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidParameters
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanLockUglyQueueWithDefaultTTL(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanLockUglyQueueWithDefaultTTL(\Cybercinch\UglyQueue $uglyQueue)
     {
         $locked = $uglyQueue->lock();
 
@@ -298,13 +297,13 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeExistingQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCannotLockQueueThatIsAlreadyLocked(\DCarbone\UglyQueue $uglyQueue)
+    public function testCannotLockQueueThatIsAlreadyLocked(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $lock = $uglyQueue->lock();
@@ -313,12 +312,12 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanLockUglyQueueWithDefaultTTL
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsTrueAfterLocking(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsTrueAfterLocking(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $isLocked = $uglyQueue->isAlreadyLocked();
@@ -326,14 +325,14 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::unlock
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::unlock
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanLockUglyQueueWithDefaultTTL
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanUnlockLockedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanUnlockLockedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $uglyQueue->unlock();
@@ -344,12 +343,12 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsFalseAfterUnlockingQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsFalseAfterUnlockingQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $isLocked = $uglyQueue->isAlreadyLocked();
@@ -358,14 +357,14 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsFalseWithStaleQueueLockFile(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsFalseWithStaleQueueLockFile(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $uglyQueue->lock(2);
@@ -379,14 +378,14 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\isAlreadyLocked::isAlreadyLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanLockQueueWithValidIntegerValue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanLockQueueWithValidIntegerValue(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $locked = $uglyQueue->lock(200);
@@ -406,14 +405,14 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::addItem
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::addItem
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanLockQueueWithValidIntegerValue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         foreach(array_reverse($this->tastySandwich, true) as $k=>$v)
@@ -426,7 +425,7 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
             $uglyQueue->getQueueTmpFile(),
             'queue.tmp file was not created!');
 
-        $lineCount = \DCarbone\Helpers\FileHelper::getLineCount($uglyQueue->getQueueTmpFile());
+        $lineCount = \Dcarbone\Helpers\FileHelper::getLineCount($uglyQueue->getQueueTmpFile());
 
         $this->assertEquals(11, $lineCount);
 
@@ -434,13 +433,13 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::_populateQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::_populateQueue
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanForciblyUpdateQueueFileFromTempFile(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanForciblyUpdateQueueFileFromTempFile(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $uglyQueue->_populateQueue();
@@ -453,13 +452,13 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::count
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetCountOfItemsInPopulatedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetCountOfItemsInPopulatedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
         $itemCount = count($uglyQueue);
 
@@ -467,12 +466,12 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::keyExistsInQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::keyExistsInQueue
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testKeyExistsReturnsTrueWithPopulatedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testKeyExistsReturnsTrueWithPopulatedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $exists = $uglyQueue->keyExistsInQueue(5);
@@ -481,41 +480,40 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::retrieveItems
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToProcessLockedQueueWithNonInteger(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToProcessLockedQueueWithNonInteger(\Cybercinch\UglyQueue $uglyQueue)
     {
-        
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->retrieveItems('Eleventy Billion');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::retrieveItems
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @expectedException
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToProcessLockedQueueWithIntegerLessThan1(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToProcessLockedQueueWithIntegerLessThan1(\Cybercinch\UglyQueue $uglyQueue)
     {
-        
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->retrieveItems(0);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::retrieveItems
-     * @covers \DCarbone\UglyQueue::count
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanGetPartialQueueContents(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetPartialQueueContents(\Cybercinch\UglyQueue $uglyQueue)
     {
         
         $process = $uglyQueue->retrieveItems(5);
@@ -531,15 +529,15 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::retrieveItems
-     * @covers \DCarbone\UglyQueue::count
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanGetPartialQueueContents
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanGetFullQueueContents(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetFullQueueContents(\Cybercinch\UglyQueue $uglyQueue)
     {
         $process = $uglyQueue->retrieveItems(6);
 
diff --git a/tests/UglyQueueManager/UglyQueueManagerTest.php b/tests/UglyQueueManager/UglyQueueManagerTest.php
index 7f5bbb8..f94ade1 100644
--- a/tests/UglyQueueManager/UglyQueueManagerTest.php
+++ b/tests/UglyQueueManager/UglyQueueManagerTest.php
@@ -3,7 +3,7 @@
 /**
  * Class UglyQueueManagerTest
  */
-class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
+class UglyQueueManagerTest extends PHPUnit\Framework\TestCase
 {
     protected $baseDir;
 
@@ -13,47 +13,47 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
         '2' => 'boneless pork ribs',
     );
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->baseDir = realpath(__DIR__.'/../misc/queues');
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::__construct
-     * @covers \DCarbone\UglyQueue::unserialize
-     * @covers \DCarbone\UglyQueueManager::addQueue
-     * @covers \DCarbone\UglyQueueManager::containsQueueWithName
-     * @uses \DCarbone\UglyQueueManager
-     * @uses \DCarbone\UglyQueue
-     * @return \DCarbone\UglyQueueManager
+     * @covers \Cybercinch\UglyQueueManager::__construct
+     * @covers \Cybercinch\UglyQueue::unserialize
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueueManager
      */
     public function testCanInitializeObjectWithValidPath()
     {
-        $manager = new \DCarbone\UglyQueueManager($this->baseDir);
+        $manager = new \Cybercinch\UglyQueueManager($this->baseDir);
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueueManager', $manager);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueueManager', $manager);
 
         return $manager;
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::__construct
-     * @uses \DCarbone\UglyQueueManager
-     * @expectedException \RuntimeException
+     * @covers \Cybercinch\UglyQueueManager::__construct
+     * @uses \Cybercinch\UglyQueueManager
      */
     public function testExceptionThrownDuringConstructionWithInvalidBasePathValue()
     {
-        new \DCarbone\UglyQueueManager('i do not exist!');
+        $this->expectException(RuntimeException::class);
+        new \Cybercinch\UglyQueueManager('i do not exist!');
     }
 
 
     /**
-     * @covers \DCarbone\UglyQueueManager::containsQueueWithName
-     * @uses \DCarbone\UglyQueueManager
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanDetermineIfValidQueueExistsInManager(\DCarbone\UglyQueueManager $manager)
+    public function testCanDetermineIfValidQueueExistsInManager(\Cybercinch\UglyQueueManager $manager)
     {
         $shouldBeTrue = $manager->containsQueueWithName('tasty-sandwich');
 
@@ -61,12 +61,12 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::containsQueueWithName
-     * @uses \DCarbone\UglyQueueManager
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanDetermineQueueDoesNotExistInManager(\DCarbone\UglyQueueManager $manager)
+    public function testCanDetermineQueueDoesNotExistInManager(\Cybercinch\UglyQueueManager $manager)
     {
         $shouldBeFalse = $manager->containsQueueWithName('i should not exist');
 
@@ -74,95 +74,95 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::getQueueWithName
-     * @uses \DCarbone\UglyQueueManager
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanGetUglyQueueObjectFromManager(\DCarbone\UglyQueueManager $manager)
+    public function testCanGetUglyQueueObjectFromManager(\Cybercinch\UglyQueueManager $manager)
     {
         $uglyQueue = $manager->getQueueWithName('tasty-sandwich');
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
         $this->assertEquals('tasty-sandwich', $uglyQueue->getName());
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::getQueueWithName
-     * @uses \DCarbone\UglyQueueManager
-     * @expectedException \InvalidArgumentException
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testExceptionThrownWhenTryingToGetNonExistentQueueFromManager(\DCarbone\UglyQueueManager $manager)
+    public function testExceptionThrownWhenTryingToGetNonExistentQueueFromManager(\Cybercinch\UglyQueueManager $manager)
     {
+        $this->expectException(InvalidArgumentException::class);
         $manager->getQueueWithName('sandwiches');
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::getQueueList
-     * @uses \DCarbone\UglyQueueManager
+     * @covers \Cybercinch\UglyQueueManager::getQueueList
+     * @uses \Cybercinch\UglyQueueManager
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanGetListOfQueuesInManager(\DCarbone\UglyQueueManager $manager)
+    public function testCanGetListOfQueuesInManager(\Cybercinch\UglyQueueManager $manager)
     {
         $queueList = $manager->getQueueList();
 
-        $this->assertInternalType('array', $queueList);
+        $this->assertIsArray($queueList);
         $this->assertCount(1, $queueList);
         $this->assertContains('tasty-sandwich', $queueList);
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::getQueueWithName
-     * @covers \DCarbone\UglyQueueManager::addQueue
-     * @uses \DCarbone\UglyQueueManager
-     * @uses \DCarbone\UglyQueue
-     * @expectedException \RuntimeException
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testExceptionThrownWhenReAddingQueueToManager(\DCarbone\UglyQueueManager $manager)
+    public function testExceptionThrownWhenReAddingQueueToManager(\Cybercinch\UglyQueueManager $manager)
     {
+        $this->expectException(RuntimeException::class);
         $uglyQueue = $manager->getQueueWithName('tasty-sandwich');
 
         $manager->addQueue($uglyQueue);
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::addQueueAtPath
-     * @covers \DCarbone\UglyQueueManager::addQueue
-     * @covers \DCarbone\UglyQueueManager::getQueueWithName
-     * @uses \DCarbone\UglyQueueManager
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueueManager::addQueueAtPath
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanInitializeNewQueueAndAddToManager(\DCarbone\UglyQueueManager $manager)
+    public function testCanInitializeNewQueueAndAddToManager(\Cybercinch\UglyQueueManager $manager)
     {
         $manager->addQueueAtPath($this->baseDir.'/really-tasty-sandwich');
 
         $uglyQueue = $manager->getQueueWithName('really-tasty-sandwich');
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
         $this->assertEquals('really-tasty-sandwich', $uglyQueue->getName());
 
         $queueList = $manager->getQueueList();
 
-        $this->assertInternalType('array', $queueList);
+        $this->assertIsArray($queueList);
         $this->assertCount(2, $queueList);
         $this->assertContains('really-tasty-sandwich', $queueList);
     }
 
     /**
-     * @covers \DCarbone\UglyQueueManager::removeQueueByName
-     * @uses \DCarbone\UglyQueueManager
+     * @covers \Cybercinch\UglyQueueManager::removeQueueByName
+     * @uses \Cybercinch\UglyQueueManager
      * @depends testCanInitializeObjectWithValidPath
-     * @param \DCarbone\UglyQueueManager $manager
+     * @param \Cybercinch\UglyQueueManager $manager
      */
-    public function testCanRemoveQueueFromManagerByName(\DCarbone\UglyQueueManager $manager)
+    public function testCanRemoveQueueFromManagerByName(\Cybercinch\UglyQueueManager $manager)
     {
         $manager->removeQueueByName('really-tasty-sandwich');
 
@@ -173,12 +173,12 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
     }
 
 //    /**
-//     * @covers \DCarbone\UglyQueue::queueExists
-//     * @uses \DCarbone\UglyQueue
+//     * @covers \Cybercinch\UglyQueue::queueExists
+//     * @uses \Cybercinch\UglyQueue
 //     * @depends testCanInitializeNewUglyQueue
-//     * @param \DCarbone\UglyQueue $uglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
 //     */
-//    public function testCanDetermineExistenceOfExistingQueue(\DCarbone\UglyQueue $uglyQueue)
+//    public function testCanDetermineExistenceOfExistingQueue(\Cybercinch\UglyQueue $uglyQueue)
 //    {
 //        $exists = $uglyQueue->queueExists('tasty-sandwich');
 //
@@ -186,12 +186,12 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
 //    }
 //
 //    /**
-//     * @covers \DCarbone\UglyQueue::queueExists
-//     * @uses \DCarbone\UglyQueue
+//     * @covers \Cybercinch\UglyQueue::queueExists
+//     * @uses \Cybercinch\UglyQueue
 //     * @depends testCanInitializeNewUglyQueue
-//     * @param \DCarbone\UglyQueue $uglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
 //     */
-//    public function testCanDetermineExistenceOfNonExistingQueue(\DCarbone\UglyQueue $uglyQueue)
+//    public function testCanDetermineExistenceOfNonExistingQueue(\Cybercinch\UglyQueue $uglyQueue)
 //    {
 //        $exists = $uglyQueue->queueExists('nasty-sandwich');
 //
@@ -199,12 +199,12 @@ class UglyQueueManagerTest extends PHPUnit_Framework_TestCase
 //    }
 //
 //    /**
-//     * @covers \DCarbone\UglyQueue::getInitializedQueueList
-//     * @uses \DCarbone\UglyQueue
+//     * @covers \Cybercinch\UglyQueue::getInitializedQueueList
+//     * @uses \Cybercinch\UglyQueue
 //     * @depends testCanInitializeNewUglyQueue
-//     * @param \DCarbone\UglyQueue $uglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
 //     */
-//    public function testCanGetListOfInitializedQueues(\DCarbone\UglyQueue $uglyQueue)
+//    public function testCanGetListOfInitializedQueues(\Cybercinch\UglyQueue $uglyQueue)
 //    {
 //        $queueList = $uglyQueue->getInitializedQueueList();
 //