diff --git a/lib/kiss/kiss.rb b/lib/kiss/kiss.rb
index a53f895318eebe9089ff7ee50681891b3e5ed330..4a4fd006705ab5667d2d2a24064f1696ea885546 100644
--- a/lib/kiss/kiss.rb
+++ b/lib/kiss/kiss.rb
@@ -16,10 +16,15 @@ module KISS
 
         private
         def self.strip_df_start(frame)
-            while frame[0] == KISS::DATA_FRAME
+            while frame[0] == DATA_FRAME
                 frame.shift
             end
-            frame.strip
+            while frame[0]&.chr == ' '
+                frame.shift
+            end
+            while frame[-1]&.chr == ' '
+                frame.pop
+            end
             return frame
         end
 
@@ -27,10 +32,10 @@ module KISS
         def self.escape_special_codes(raw_code_bytes)
             encoded_bytes = []
             raw_code_bytes.each do |raw_code_byte|
-                if raw_code_byte == KISS::FESC
-                    encoded_bytes += KISS::FESC_TFESC
-                elsif raw_code_byte == KISS::FEND
-                    encoded_bytes += KISS::FESC_TFEND
+                if raw_code_byte == FESC
+                    encoded_bytes += FESC_TFESC
+                elsif raw_code_byte == FEND
+                    encoded_bytes += FESC_TFEND
                 else
                     encoded_bytes += [raw_code_byte]
                 end
@@ -62,11 +67,11 @@ module KISS
         def fill_buffer
             new_frames = []
             read_buffer = []
-            read_data = self.read_interface
-            while read_data&.length
+            read_data = read_interface
+            while read_data&.length and read_data.length > 0
                 split_data = [[]]
                 read_data.each do |read_byte|
-                    if read_byte == KISS::FEND
+                    if read_byte == FEND
                         split_data << []
                     else
                         split_data[-1] << read_byte
@@ -79,7 +84,7 @@ module KISS
                     read_buffer += split_data[0]
                 # Single FEND in frame
                 elsif len_fend == 2
-                # Closing FEND found
+                    # Closing FEND found
                     if split_data[0]
                         # Partial frame continued, otherwise drop
                         new_frames << read_buffer + split_data[0]
@@ -93,7 +98,7 @@ module KISS
                 elsif len_fend >= 3
                     (0...len_fend - 1).each do |i|
                         read_buffer_tmp = read_buffer + split_data[i]
-                        if read_buffer_tmp.length
+                        if read_buffer_tmp.length > 0
                             new_frames << read_buffer_tmp
                             read_buffer = []
                         end
@@ -103,11 +108,11 @@ module KISS
                     end
                 end
                 # Get anymore data that is waiting
-                read_data = self.read_interface
+                read_data = read_interface
             end
-
+            
             new_frames.each do |new_frame|
-                if new_frame.length and not new_frame[0]
+                if new_frame.length > 0 and new_frame[0] == 0
                     if @strip_df_start
                         new_frame = KISS.strip_df_start(new_frame)
                     end
@@ -116,22 +121,25 @@ module KISS
             end
         end
 
+        public
         def connect(mode_init=None, *args, **kwargs)
         end
 
+        public
         def close
             if @exit_kiss
-                self.write_interface(KISS::MODE_END)
+                write_interface(MODE_END)
             end
         end
 
+        public
         def read
             @lock.synchronize do
-                if @frame_buffer.length > 0
-                    self.fill_buffer
+                if @frame_buffer.length == 0
+                    fill_buffer
                 end
 
-                if @frame_buffer.length
+                if @frame_buffer.length > 0
                     return_frame = @frame_buffer[0]
                     @frame_buffer.shift
                     return return_frame
@@ -141,10 +149,11 @@ module KISS
             end
         end
 
+        public
         def write(frame_bytes, port=0)
             @lock.synchronize do
-                kiss_packet = [KISS:FEND] + [self.command_byte_combine(port, KISS::DATA_FRAME)] +
-                    self.escape_special_codes(frame_bytes) + [KISS::FEND]
+                kiss_packet = [FEND] + [command_byte_combine(port, DATA_FRAME)] +
+                    escape_special_codes(frame_bytes) + [FEND]
 
                 return self.write_interface(kiss_packet)
             end
diff --git a/test/tc_kiss.rb b/test/tc_kiss.rb
new file mode 100644
index 0000000000000000000000000000000000000000..489fffa258fc3d3f9228e90d3170d3af04c04f9b
--- /dev/null
+++ b/test/tc_kiss.rb
@@ -0,0 +1,62 @@
+require 'test/unit'
+require_relative '../lib/kiss/kiss'
+
+module KISS
+# KG6WTF>S7TSUV,MTOSO-2,WIDE2*,qAR,KF6FIR-10:`17El#X-/kg6wtf@gosselinfamily.com
+    ENCODED_FRAME = [192, 0, 75, 71, 54, 87, 84, 70, 62, 83, 55, 84, 83, 85, 86, 44, 77, 84, 79, 83, 79, 45, 50, 44, 87, 73,
+                     68, 69, 50, 42, 44, 113, 65, 82, 44, 75, 70, 54, 70, 73, 82, 45, 49, 48, 58, 96, 49, 55, 69, 108, 35,
+                     88, 45, 47, 107, 103, 54, 119, 116, 102, 64, 103, 111, 115, 115, 101, 108, 105, 110, 102, 97, 109, 105,
+                     108, 121, 46, 99, 111, 109, 192]
+    DECODED_FRAME = [75, 71, 54, 87, 84, 70, 62, 83, 55, 84, 83, 85, 86, 44, 77, 84, 79, 83, 79, 45, 50, 44, 87, 73, 68,
+                     69, 50, 42, 44, 113, 65, 82, 44, 75, 70, 54, 70, 73, 82, 45, 49, 48, 58, 96, 49, 55, 69, 108, 35,
+                     88, 45, 47, 107, 103, 54, 119, 116, 102, 64, 103, 111, 115, 115, 101, 108, 105, 110, 102, 97, 109,
+                     105, 108, 121, 46, 99, 111, 109]
+    
+    class KISSMock < KISS
+        
+        def initialize(strip_df_start=true)
+            super(strip_df_start)
+            @read_from_interface = []
+            @sent_to_interface = []
+        end
+        
+        protected
+        def read_interface
+            if @read_from_interface.length == 0
+                return nil
+            end
+            return @read_from_interface.shift
+        end
+        
+        protected
+        def write_interface(data)
+            @sent_to_interface << data
+        end
+        
+        public
+        def clear_interface
+            @read_from_interface = []
+            @sent_to_interface = []
+        end
+
+        public
+        def add_read_from_interface(raw_frame)
+            @read_from_interface << raw_frame
+        end
+
+        public
+        def get_sent_to_interface
+            return @sent_to_interface
+        end
+    end
+    
+    class TestKISS < Test::Unit::TestCase
+        def test_read
+            kiss_mock = KISSMock.new
+            kiss_mock.add_read_from_interface(ENCODED_FRAME)
+            translated_frame = kiss_mock.read
+            assert DECODED_FRAME == translated_frame
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/test/tc_something.rb b/test/tc_something.rb
deleted file mode 100644
index 9148cbc56db6f2c607cdf261269840a1b6c56b02..0000000000000000000000000000000000000000
--- a/test/tc_something.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'test/unit'
-
-class TestSomething < Test::Unit::TestCase
-  def test_truth
-    assert true
-  end
-end