feat: Enhance transports, response parsing, and tests

Multiple improvements across fastboot transports, protocol handling, USB behavior, and tests:

- Tests: add many unit tests and test helpers (MockTransport, ProtocolDownloadCaptureTransport, DelegatingTransport) covering packed frames, DATA parsing, download/upload edge cases, UDP behaviors, and GetVar caching.
- UDP: refactor UdpTransport constructor to accept timeout and max attempts, enforce timeouts, validate packet sizes, implement proper continuation handling, sequence tracking, out-of-turn data/error detection, and clearer error reporting.
- TCP: add connect/read/write timeouts and use ConnectAsync with a timeout to avoid hangs during handshake.
- USB: align host behavior with AOSP by avoiding forced host-side ZLPs (Linux, macOS, WinUSB), and add IO timeouts for legacy Windows device reads/writes using tasks to prevent blocking.
- FastbootUtil: reduce OnceSendDataSize to 512KB for better compatibility, avoid caching transient getvar failures, clamp sparse download logic, ensure SparseFile is disposed, and add validation for download sizes and stream EOF handling.
- HandleResponse: make response parsing more robust for packed INFO/TEXT frames, fragmented prefixes, DATA size validation (hex/length checks), and better timeout handling.

These changes improve reliability, timeout behavior, and correctness when communicating with various fastboot implementations and increase test coverage for edge cases.

Author: 13584452567

FirmwareKit.Comm.Fastboot.Tests/FastbootInfoTests.cs

@@ -196,5 +196,83 @@ public void FlashFromInfo_RebootCommands_MappedCorrectly()
             Assert.Contains("reboot-bootloader", transport.Commands);
             Assert.Contains("reboot", transport.Commands);
         }
+
+        [Fact]
+        public void GetMaxDownloadSize_ClampsToSparseLimit()
+        {
+            int originalLimit = FastbootUtil.SparseMaxDownloadSize;
+            try
+            {
+                FastbootUtil.SparseMaxDownloadSize = 1024 * 1024 * 1024;
+                var transport = new ProtocolScriptTransport(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+                {
+                    ["getvar:max-download-size"] = "OKAY0x80000000"
+                });
+                var util = new FastbootUtil(transport);
+
+                long maxDownloadSize = util.GetMaxDownloadSize();
+
+                Assert.Equal(FastbootUtil.SparseMaxDownloadSize, maxDownloadSize);
+            }
+            finally
+            {
+                FastbootUtil.SparseMaxDownloadSize = originalLimit;
+            }
+        }
+
+        [Fact]
+        public void GetVar_FailureIsNotCached_AllowsRetrySuccess()
+        {
+            // First read fails, second read succeeds for same key.
+            int attempt = 0;
+            string key = "max-download-size";
+
+            var util = new FastbootUtil(new DelegatingTransport(
+                onWrite: (cmd) =>
+                {
+                    if (cmd.Equals("getvar:" + key, StringComparison.OrdinalIgnoreCase))
+                    {
+                        attempt++;
+                        return attempt == 1 ? "FAILtemporary" : "OKAY0x100000";
+                    }
+                    return "OKAY";
+                }));
+
+            string first = util.GetVar(key);
+            string second = util.GetVar(key);
+
+            Assert.Equal(string.Empty, first);
+            Assert.Equal("0x100000", second);
+        }
+
+        private sealed class DelegatingTransport : IFastbootTransport
+        {
+            private readonly Func<string, string> _onWrite;
+            private readonly Queue<byte[]> _readQueue = new();
+
+            public DelegatingTransport(Func<string, string> onWrite)
+            {
+                _onWrite = onWrite;
+            }
+
+            public byte[] Read(int length)
+            {
+                if (_readQueue.Count == 0)
+                {
+                    return Encoding.UTF8.GetBytes("OKAY");
+                }
+                return _readQueue.Dequeue();
+            }
+
+            public long Write(byte[] data, int length)
+            {
+                string cmd = Encoding.UTF8.GetString(data, 0, length);
+                string response = _onWrite(cmd);
+                _readQueue.Enqueue(Encoding.UTF8.GetBytes(response));
+                return length;
+            }
+
+            public void Dispose() { }
+        }
     }
 }