Add unit tests

.editorconfig

@@ -0,0 +1,7 @@
+[*.cs]
+
+# IDE0008: Use explicit type
+dotnet_diagnostic.IDE0008.severity = silent
+
+# IDE0300: Simplify collection initialization
+dotnet_diagnostic.IDE0300.severity = silent

TechnitiumLibrary.IO/BinaryReaderExtensions.cs

@@ -28,7 +28,14 @@ public static class BinaryReaderExtensions
     {
         public static byte[] ReadBuffer(this BinaryReader bR)
         {
-            return bR.ReadBytes(ReadLength(bR));
+            int len = ReadLength(bR);
+
+            byte[] buffer = bR.ReadBytes(len);
+
+            if (buffer.Length != len)
+                throw new EndOfStreamException("Unexpected end of stream while reading buffer.");
+
+            return buffer;
         }
 
         public static string ReadShortString(this BinaryReader bR)
@@ -38,32 +45,53 @@ public static string ReadShortString(this BinaryReader bR)
 
         public static string ReadShortString(this BinaryReader bR, Encoding encoding)
         {
-            return encoding.GetString(bR.ReadBytes(bR.ReadByte()));
+            int length = bR.ReadByte();
+            byte[] bytes = bR.ReadBytes(length);
+
+            if (bytes.Length != length)
+                throw new EndOfStreamException("Not enough bytes to read short string.");
+
+            return encoding.GetString(bytes);
         }
 
         public static DateTime ReadDateTime(this BinaryReader bR)
         {
-            return DateTime.UnixEpoch.AddMilliseconds(bR.ReadInt64());
+            // Read int64 big-endian timestamp (same as original behavior because .NET native is LE)
+            Span<byte> buffer = stackalloc byte[8];
+            int read = bR.BaseStream.Read(buffer);
+
+            if (read != 8)
+                throw new EndOfStreamException("Not enough bytes to read DateTime ticks.");
+
+            long millis = BinaryPrimitives.ReadInt64LittleEndian(buffer);
+            return DateTime.UnixEpoch.AddMilliseconds(millis);
         }
 
         public static int ReadLength(this BinaryReader bR)
         {
-            int length1 = bR.ReadByte();
-            if (length1 > 127)
-            {
-                int numberLenBytes = length1 & 0x7F;
-                if (numberLenBytes > 4)
-                    throw new IOException("BinaryReaderExtension encoding length not supported.");
-
-                Span<byte> valueBytes = stackalloc byte[4];
-                bR.BaseStream.ReadExactly(valueBytes.Slice(4 - numberLenBytes, numberLenBytes));
-
-                return BinaryPrimitives.ReadInt32BigEndian(valueBytes);
-            }
-            else
-            {
-                return length1;
-            }
+            int first = bR.ReadByte();
+            if (first < 0)
+                throw new EndOfStreamException("Not enough bytes for a length prefix.");
+
+            // Single byte value
+            if (first <= 127)
+                return first;
+
+            // Otherwise, multi-byte length
+            int numberLenBytes = first & 0x7F;
+
+            if (numberLenBytes > 4)
+                throw new IOException("BinaryReaderExtension encoding length not supported.");
+
+            Span<byte> temp = stackalloc byte[4];
+
+            int offset = 4 - numberLenBytes;
+            int readBytes = bR.BaseStream.Read(temp[offset..]);
+
+            if (readBytes != numberLenBytes)
+                throw new EndOfStreamException("Not enough bytes for encoded length.");
+
+            return BinaryPrimitives.ReadInt32BigEndian(temp);
         }
     }
-}
+}

TechnitiumLibrary.IO/Joint.cs

@@ -1,24 +1,6 @@
-/*
-Technitium Library
-Copyright (C) 2024  Shreyas Zare (shreyas@technitium.com)
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-using System;
+using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace TechnitiumLibrary.IO
@@ -36,6 +18,9 @@ public class Joint : IDisposable
         readonly Stream _stream1;
         readonly Stream _stream2;
 
+        // track copy completion
+        private int _pendingCopies = 2;
+
         #endregion
 
         #region constructor
@@ -72,11 +57,8 @@ protected virtual void Dispose(bool disposing)
                 {
                     Disposing?.Invoke(this, EventArgs.Empty);
 
-                    if (_stream1 != null)
-                        _stream1.Dispose();
-
-                    if (_stream2 != null)
-                        _stream2.Dispose();
+                    _stream1?.Dispose();
+                    _stream2?.Dispose();
                 }
             }
         }
@@ -85,6 +67,12 @@ protected virtual void Dispose(bool disposing)
 
         #region private
 
+        private void OnCopyFinished()
+        {
+            if (Interlocked.Decrement(ref _pendingCopies) == 0)
+                Dispose();
+        }
+
         private async Task CopyToAsync(Stream src, Stream dst)
         {
             try
@@ -93,7 +81,7 @@ private async Task CopyToAsync(Stream src, Stream dst)
             }
             finally
             {
-                Dispose();
+                OnCopyFinished();
             }
         }
 
@@ -111,11 +99,9 @@ public void Start()
 
         #region properties
 
-        public Stream Stream1
-        { get { return _stream1; } }
+        public Stream Stream1 => _stream1;
 
-        public Stream Stream2
-        { get { return _stream2; } }
+        public Stream Stream2 => _stream2;
 
         #endregion
     }

TechnitiumLibrary.IO/PackageItem.cs

@@ -154,9 +154,14 @@ public static PackageItem Parse(Stream s)
                         item._extractToCustomLocation = Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadByte()));
 
                     long length = bR.ReadInt64();
-                    item._data = new OffsetStream(bR.BaseStream, bR.BaseStream.Position, length, true);
 
-                    bR.BaseStream.Position += length;
+                    long startOffset = bR.BaseStream.Position;
+
+                    // Create slice before advancing stream pointer
+                    item._data = new OffsetStream(bR.BaseStream, startOffset, length, readOnly: true);
+
+                    // Seek explicitly
+                    bR.BaseStream.Seek(length, SeekOrigin.Current);
 
                     return item;
 

TechnitiumLibrary.Net/DomainEndPoint.cs

@@ -61,6 +61,12 @@ private DomainEndPoint()
 
         public static bool TryParse(string value, out DomainEndPoint ep)
         {
+            if (string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value))
+            {
+                ep = null;
+                return false;
+            }
+
             string[] parts = value.Split(':');
             if (parts.Length > 2)
             {

TechnitiumLibrary.Net/EndPointExtensions.cs

@@ -181,20 +181,33 @@ public static EndPoint GetEndPoint(string address, int port)
 
         public static bool TryParse(string value, out EndPoint ep)
         {
+            ep = null;
+            if (string.IsNullOrWhiteSpace(value))
+                return false;
+
+            // First handle IP:port
             if (IPEndPoint.TryParse(value, out IPEndPoint ep1))
             {
                 ep = ep1;
                 return true;
             }
 
-            if (DomainEndPoint.TryParse(value, out DomainEndPoint ep2))
-            {
-                ep = ep2;
-                return true;
-            }
+            // Now handle domain:port
+            int idx = value.LastIndexOf(':');
+            if (idx <= 0) // must be >0 because first char cannot be colon
+                return false;
 
-            ep = null;
-            return false;
+            string host = value.Substring(0, idx);
+            string portText = value.Substring(idx + 1);
+
+            if (!int.TryParse(portText, out int port) || port < 0 || port > 65535)
+                return false;
+
+            if (!DomainEndPoint.TryParse(value, out DomainEndPoint ep2))
+                return false;
+
+            ep = ep2;
+            return true;
         }
 
         public static bool IsEquals(this EndPoint ep, EndPoint other)
@@ -208,18 +221,12 @@ public static bool IsEquals(this EndPoint ep, EndPoint other)
             if (ep.AddressFamily != other.AddressFamily)
                 return false;
 
-            switch (ep.AddressFamily)
+            return ep.AddressFamily switch
             {
-                case AddressFamily.InterNetwork:
-                case AddressFamily.InterNetworkV6:
-                    return (ep as IPEndPoint).Equals(other);
-
-                case AddressFamily.Unspecified:
-                    return (ep as DomainEndPoint).Equals(other);
-
-                default:
-                    throw new NotSupportedException("Address Family not supported.");
-            }
+                AddressFamily.InterNetwork or AddressFamily.InterNetworkV6 => (ep as IPEndPoint).Equals(other),
+                AddressFamily.Unspecified => (ep as DomainEndPoint).Equals(other),
+                _ => throw new NotSupportedException("Address Family not supported."),
+            };
         }
 
         #endregion