public void ExtractedBytes_Equals_Returns_Correct_Value()
        {
            var obj1 = new ExtractedBytes() { Bytes = new byte[] { 0x01, 0x02, 0x03 }, Format = ExtractedBytesFormat.ModeS, Offset = 0, Length = 1, ChecksumFailed = false, HasParity = false };
            var obj2 = new ExtractedBytes() { Bytes = new byte[] { 0x01, 0x02, 0x03 }, Format = ExtractedBytesFormat.ModeS, Offset = 0, Length = 1, ChecksumFailed = false, HasParity = false };

            Assert.AreEqual(obj1, obj2);

            obj1.Bytes[2] = 0x0f;
            Assert.AreNotEqual(obj1, obj2);

            obj1.Bytes = obj2.Bytes;
            obj1.Format = ExtractedBytesFormat.Port30003;
            Assert.AreNotEqual(obj1, obj2);

            obj1.Format = obj2.Format;
            obj1.Offset = 1;
            Assert.AreNotEqual(obj1, obj2);

            obj1.Offset = obj2.Offset;
            obj1.Length = 2;
            Assert.AreNotEqual(obj1, obj2);

            obj1.Length = obj2.Length;
            obj1.ChecksumFailed = true;
            Assert.AreNotEqual(obj1, obj2);

            obj1.ChecksumFailed = obj2.ChecksumFailed;
            obj1.HasParity = true;
            Assert.AreNotEqual(obj1, obj2);
        }
        public void ExtractedBytes_Constructor_Initialises_To_Known_State_And_Properties_Work()
        {
            var extractedBytes = new ExtractedBytes();

            TestUtilities.TestProperty(extractedBytes, r => r.Bytes, null, new byte[] {});
            TestUtilities.TestProperty(extractedBytes, r => r.ChecksumFailed, false);
            TestUtilities.TestProperty(extractedBytes, r => r.Format, ExtractedBytesFormat.None, ExtractedBytesFormat.ModeS);
            TestUtilities.TestProperty(extractedBytes, r => r.HasParity, false);
            TestUtilities.TestProperty(extractedBytes, r => r.Length, 0, 1);
            TestUtilities.TestProperty(extractedBytes, r => r.Offset, 0, 1);
        }
        public void ExtractedBytes_Clone_Returns_A_Deep_Copy()
        {
            var originalByteArray = new byte[] {0x01, 0x02};

            foreach(var property in typeof(ExtractedBytes).GetProperties()) {
                var original = new ExtractedBytes();
                switch(property.Name) {
                    case "Bytes":           original.Bytes = originalByteArray; break;
                    case "ChecksumFailed":  original.ChecksumFailed = true; break;
                    case "Format":          original.Format = ExtractedBytesFormat.Port30003; break;
                    case "HasParity":       original.HasParity = true; break;
                    case "Length":          original.Length = 1; break;
                    case "Offset":          original.Offset = 1; break;
                    default:                throw new NotImplementedException();
                }

                var clone = (ExtractedBytes)original.Clone();
                Assert.AreNotSame(original, clone);

                switch(property.Name) {
                    case "Bytes":
                        Assert.IsNotNull(clone.Bytes);
                        Assert.AreNotSame(original.Bytes, clone.Bytes);
                        Assert.AreEqual(2, clone.Bytes.Length);
                        Assert.AreEqual(1, clone.Bytes[0]);
                        Assert.AreEqual(2, clone.Bytes[1]);
                        break;
                    case "ChecksumFailed":  Assert.AreEqual(true, clone.ChecksumFailed); break;
                    case "Format":          Assert.AreEqual(ExtractedBytesFormat.Port30003, clone.Format); break;
                    case "HasParity":       Assert.AreEqual(true, clone.HasParity); break;
                    case "Length":          Assert.AreEqual(1, clone.Length); break;
                    case "Offset":          Assert.AreEqual(1, clone.Offset); break;
                    default:                throw new NotImplementedException();
                }
            }
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Translates the bytes for a Port30003 message into a cooked message object and causes a message received event to be raised on the background thread.
 /// </summary>
 /// <param name="extractedBytes"></param>
 private void ProcessPort30003MessageBytes(ExtractedBytes extractedBytes)
 {
     try {
         var port30003Message = Encoding.ASCII.GetString(extractedBytes.Bytes, extractedBytes.Offset, extractedBytes.Length);
         var translatedMessage = _Port30003MessageTranslator.Translate(port30003Message);
         if(translatedMessage != null) {
             ++TotalMessages;
             if(_Statistics.Lock != null) { lock(_Statistics.Lock) ++_Statistics.BaseStationMessagesReceived; }
             _MessageProcessingAndDispatchQueue.Enqueue(new MessageDispatch() { Port30003MessageEventArgs = new BaseStationMessageEventArgs(translatedMessage) });
         }
     } catch(Exception) {
         ++TotalBadMessages;
         if(_Statistics.Lock != null) { lock(_Statistics.Lock) ++_Statistics.BaseStationBadFormatMessagesReceived; }
         if(!IgnoreBadMessages) throw;
     }
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Translates the bytes for a Mode-S message into a cooked message object and causes a message received event to be raised on the background thread.
        /// </summary>
        /// <param name="now"></param>
        /// <param name="extractedBytes"></param>
        private void ProcessModeSMessageBytes(DateTime now, ExtractedBytes extractedBytes)
        {
            if(extractedBytes.Length == 7 || extractedBytes.Length == 14) {
                if(extractedBytes.HasParity) _ModeSParity.StripParity(extractedBytes.Bytes, extractedBytes.Offset, extractedBytes.Length);

                try {
                    var modeSMessage = _ModeSMessageTranslator.Translate(extractedBytes.Bytes, extractedBytes.Offset);
                    if(modeSMessage != null) {
                        bool hasPIField = modeSMessage.ParityInterrogatorIdentifier != null;
                        bool isPIWithBadParity = hasPIField && modeSMessage.ParityInterrogatorIdentifier != 0;
                        var adsbMessage = _AdsbMessageTranslator.Translate(modeSMessage);

                        if((hasPIField || isPIWithBadParity || adsbMessage == null) && _Statistics.Lock != null) {
                            lock(_Statistics.Lock) {
                                if(hasPIField) ++_Statistics.ModeSWithPIField;
                                if(isPIWithBadParity) ++_Statistics.ModeSWithBadParityPIField;
                                if(adsbMessage == null) ++_Statistics.ModeSNotAdsbCount;
                            }
                        }

                        ++TotalMessages;
                        _MessageProcessingAndDispatchQueue.Enqueue(new MessageDispatch() { ModeSMessageEventArgs = new ModeSMessageEventArgs(now, modeSMessage, adsbMessage) });
                    }
                } catch(Exception) {
                    ++TotalBadMessages;
                    if(!IgnoreBadMessages) throw;
                }
            }
        }