public void EqualityList() { // Make initial list BList testList = new BList(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testList.Add(testString); testList.Add(testInt); // Make test list BList testList2 = new BList(); BString testString2 = new BString("Hello World"); BInt testInt2 = new BInt(5); testList2.Add(testString2); testList2.Add(testInt2); // Test equality recursive Assert.AreEqual(testList, testList2); // Test null list BList nullList = null; Assert.IsFalse(testList.Equals(nullList)); // Test different counts testList2.Add(new BInt(10)); Assert.IsFalse(testList.Equals(testList2)); // Test different values testList.Add(new BInt(9)); Assert.IsFalse(testList.Equals(testList2)); }
public void DecodeList() { const string testString = "l1:a11:Hello Worlde"; BList testExpected = new BList(); testExpected.Add(new BString("a")); testExpected.Add(new BString("Hello World")); IBencodingType testResult = BencodingUtils.Decode(testString); Assert.AreEqual(testExpected, testResult); }
public void EncodeList() { BList testList = new BList(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testList.Add(testString); testList.Add(testInt); string test = BencodingUtils.EncodeString(testList); Assert.AreEqual("l11:Hello Worldi5ee", test); }
public void BListSetNullValue() { BList list = new BList(); list.Add(new BInt(0)); list[0] = null; }
public void BListSetValue() { BList list = new BList(); list.Add(new BInt(0)); BInt newInt = new BInt(1); list[0] = newInt; Assert.AreEqual(newInt, list[0]); }
public void given_empty_blist_when_one_element_is_added_then_blist_iterator_should_return_element() { var count = 1; var expected = new int[count].Select(_ => _random.Next()).ToArray(); var blist = new BList<int>(); foreach (var item in expected) blist.Add(item); CollectionAssert.AreEqual(expected, blist); }
public void given_empty_blist_when_elements_are_added_individually_then_blist_count_should_equal_number_added() { var count = 1024; var expected = new int[count].Select(_ => _random.Next()).ToArray(); var blist = new BList<int>(); foreach (var item in expected) blist.Add(item); Assert.That(blist.Count, Is.EqualTo(count)); }
public void given_empty_blist_when_one_element_is_added_then_blist_indexer_should_return_element() { var count = 1; var expected = new int[count].Select(_ => _random.Next()).ToArray(); var blist = new BList<int>(); foreach (var item in expected) blist.Add(item); Assert.That(expected[0], Is.EqualTo(blist[0])); }
// Adds metadata about how files are treated. private static void AddInfo(string torrentName, string directoryRoot, BDictionary info, int pieceLength, List <FileData> files, List <byte[]> pieces) { info.Add(TorrentKeys.InfoPieceLength, new BInteger(pieceLength)); var bencodedPieces = new StringBuilder(); foreach (var piece in pieces) { foreach (var data in piece) { bencodedPieces.Append((char)data); } } info.Add(TorrentKeys.InfoPieces, new BString(bencodedPieces.ToString())); if (files.Count == 1) { info.Add(TorrentKeys.InfoName, new BString(torrentName)); info.Add(TorrentKeys.InfoFilesLength, new BInteger(files[0].Length)); } else if (files.Count > 1) { info.Add(TorrentKeys.InfoName, new BString(directoryRoot)); var filesList = new BList(); foreach (FileData inputFile in files) { var aFile = new BDictionary(); aFile.Add(TorrentKeys.InfoFilesLength, new BInteger(inputFile.Length)); var filePath = new BList(inputFile.Path.Split()); aFile.Add(TorrentKeys.InfoFilesPath, filePath); filesList.Add(aFile); } info.Add(TorrentKeys.InfoFiles, filesList); } else { throw new ArgumentOutOfRangeException(nameof(files)); } }
public static DHTMessage CreateFindNodeQuery(BString transactionID, byte[] nodeId) { BDictionary sendData = new BDictionary(); sendData.Add("t", transactionID); sendData.Add("y", "q"); sendData.Add("q", "find_node"); #if IP6 var want = new BList(); want.Add("n6"); sendData.Add("want", want); #endif var args = new BDictionary(); args.Add("id", new BString(nodeId)); args.Add("target", new BString(DHTHelper.GetRandomHashID())); sendData.Add("a", args); return(new DHTMessage(MessageType.Query, QueryType.FindNode, sendData)); }
public static DHTMessage CreateFindNodeQuery(BString transactionID, DHTId nodeId, DHTId targetNodeId) { BDictionary sendData = new BDictionary(); sendData.Add("t", transactionID); sendData.Add("y", "q"); sendData.Add("q", "find_node"); #if IP6 var want = new BList(); want.Add("n6"); sendData.Add("want", want); #endif var args = new BDictionary(); args.Add("id", nodeId.ToBencodedString()); args.Add("target", targetNodeId.ToBencodedString()); sendData.Add("a", args); return(new DHTMessage(MessageType.Query, QueryType.FindNode, sendData)); }
public static DHTMessage CreateGetPeersQuery(BString transactionID, DHTId nodeId, DHTId infoHash) { BDictionary sendData = new BDictionary(); sendData.Add("t", transactionID); sendData.Add("y", "q"); sendData.Add("q", "get_peers"); #if IP6 var want = new BList(); want.Add("n6"); sendData.Add("want", want); #endif var args = new BDictionary(); args.Add("id", nodeId.ToBencodedString()); args.Add("info_hash", infoHash.ToBencodedString()); sendData.Add("a", args); return(new DHTMessage(MessageType.Query, QueryType.GetPeers, sendData)); }
public static BDictionary CreateGetPeersQuery(BString transactionID, byte[] nid, byte[] infoHash) { BDictionary sendData = new BDictionary(); sendData.Add("t", transactionID); sendData.Add("y", "q"); sendData.Add("q", "get_peers"); #if IP6 var want = new BList(); want.Add("n6"); sendData.Add("want", want); #endif var args = new BDictionary(); args.Add("id", new BString(nid)); args.Add("info_hash", new BString(infoHash)); sendData.Add("a", args); return(sendData); }
public override BDictionary Construct() { BDictionary arguments = new BDictionary { { "id", new BString(QueriedNode.Bytes) }, { "token", new BString(Token.Bytes) } }; if (Peers != null) { BList peers = new BList(Peers.Length); for (int i = 0; i < Peers.Length; i++) { peers.Add(new BString(Peers[i].Encode())); } arguments.Add("values", peers); } else { if (Nodes != null) { byte[] nodes = new byte[IPv4Node.CompactInfoSize * Nodes.Length]; for (int i = 0; i < Nodes.Length; i++) { Nodes[i].Encode(((Span <byte>)nodes).Slice(i * IPv4Node.CompactInfoSize)); } arguments.Add("nodes", new BString(nodes)); } if (Nodes6 != null) { byte[] nodes6 = new byte[IPv6Node.CompactInfoSize * Nodes6.Length]; for (int i = 0; i < Nodes6.Length; i++) { Nodes6[i].Encode(((Span <byte>)nodes6).Slice(i * IPv6Node.CompactInfoSize)); } arguments.Add("nodes6", new BString(nodes6)); } } return(ConstructResponse(arguments)); }
public static BDictionary GetInfoDictionary(TorrentInfo info) { var infoDic = new BDictionary { { Constants.InfoPieceLengthKey, info.PieceLength }, { Constants.InfoPiecesKey, info.Pieces } }; if (info.Name != null) { infoDic.Add(Constants.InfoNameKey, info.Name); } foreach (var(key, value) in info.Extensions) { infoDic.Add(key, value); } if (info.Files.Count == 1) { var(path, len) = info.Files[0]; infoDic.Add(Constants.InfoLengthKey, len); } else { var lst = new BList(info.Files.Count); foreach (var(key, value) in info.Files) { var fdic = new BDictionary { { Constants.InfoFilePathKey, key }, { Constants.InfoFileLengthKey, value } }; lst.Add(fdic); } infoDic.Add(Constants.InfoFilesKey, lst); } return(infoDic); }
public void SetNullValue() { var blist = new BList(); blist.Add(0); blist[0] = null; }
given_existing_blist_when_elements_are_inserted_at_index_zero_then_blist_iterator_should_return_correct_latest_elements () { var initial = new int[512].Select(_ => _random.Next()).ToArray(); var insertzero = new int[256].Select(_ => _random.Next()).ToArray(); var expected = insertzero.Reverse().Concat(initial).ToArray(); var blist = new BList<int>(); foreach (var item in initial) blist.Add(item); foreach (var item in insertzero) blist.Insert(0, item); CollectionAssert.AreEqual(expected, blist); }
private static BList ReadList(BinaryReader binaryReader) { Contract.Requires(binaryReader != null); byte i = binaryReader.ReadByte(); if (i != 'l') { throw Error(); } BList lst = new BList(); try { for (int c = binaryReader.PeekChar(); ; c = binaryReader.PeekChar()) { if (c == -1) throw Error(); if (c == 'e') { binaryReader.ReadByte(); break; } lst.Add(ReadElement(binaryReader)); } } catch (BencodingException) { throw; } catch (Exception e) { throw Error(e); } return lst; }
public void AddNullValue() { var blist = new BList(); blist.Add((IBObject)null); }
/// <summary> /// Creates the 'info' part of the torrent. /// </summary> /// <param name="encoding">The encoding used for writing strings</param> /// <returns>A <see cref="BDictionary"/> of the 'info' part of the torrent</returns> protected virtual BDictionary CreateInfoDictionary(Encoding encoding) { var info = new BDictionary(); if (PieceSize > 0) info[TorrentInfoFields.PieceLength] = (BNumber) PieceSize; if (Pieces?.Length > 0) info[TorrentInfoFields.Pieces] = new BString(Pieces, encoding); if (IsPrivate) info[TorrentInfoFields.Private] = (BNumber)1; if (FileMode == TorrentFileMode.Single) { info[TorrentInfoFields.Name] = new BString(File.FileName, encoding); info[TorrentInfoFields.Length] = (BNumber)File.FileSize; if (File.Md5Sum != null) info[TorrentInfoFields.Md5Sum] = new BString(File.Md5Sum, encoding); } else if (FileMode == TorrentFileMode.Multi) { info[TorrentInfoFields.Name] = new BString(Files.DirectoryName, encoding); var files = new BList<BDictionary>(); foreach (var file in Files) { var fileDictionary = new BDictionary { [TorrentFilesFields.Length] = (BNumber)file.FileSize, [TorrentFilesFields.Path] = new BList(file.Path) }; if (file.Md5Sum != null) fileDictionary[TorrentFilesFields.Md5Sum] = new BString(file.Md5Sum, encoding); files.Add(fileDictionary); } info[TorrentInfoFields.Files] = files; } return info; }
public void BListAddNullValue() { BList list = new BList(); list.Add(null); }
static void HandleMessage(BDictionary message, TcpClient client) { var opValue = message["op"]; var opString = opValue as BString; var autoCompletionSupportEnabled = RT.booleanCast(((IPersistentMap)configVar.invoke()).valAt(Keyword.intern("nrepl-auto-completion"))); if (opString != null) { var session = GetSession(message); switch (opString.ToString()) { case "clone": var newSession = CloneSession(session); SendMessage( new BDictionary { { "id", message["id"] }, { "status", new BList { "done" } }, { "new-session", newSession.ToString() } }, client); break; case "describe": // TODO include arcadia version var clojureVersion = (IPersistentMap)RT.var("clojure.core", "*clojure-version*").deref(); var clojureMajor = (int)clojureVersion.valAt(Keyword.intern("major")); var clojureMinor = (int)clojureVersion.valAt(Keyword.intern("minor")); var clojureIncremental = (int)clojureVersion.valAt(Keyword.intern("incremental")); var clojureQualifier = (string)clojureVersion.valAt(Keyword.intern("qualifier")); var supportedOps = new BDictionary { { "eval", 1 }, { "load-file", 1 }, { "describe", 1 }, { "clone", 1 }, { "info", 1 }, { "eldoc", 1 }, { "classpath", 1 }, }; // Debug.Log("Autocomplete support is enabled?: " + autoCompletionSupportEnabled); if (autoCompletionSupportEnabled) { supportedOps.Add("complete", 1); } SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "ops", supportedOps }, { "versions", new BDictionary { { "clojure", new BDictionary { { "major", clojureMajor }, { "minor", clojureMinor }, { "incremental", clojureIncremental }, { "qualifier", clojureQualifier } } }, { "nrepl", new BDictionary { { "major", 0 }, { "minor", 2 }, { "incremental", 3 } } } } } }, client); break; case "eval": var fn = new EvalFn(message, client); addCallbackVar.invoke(fn); break; case "load-file": message["code"] = new BString("(do " + message["file"].ToString() + " )"); var loadFn = new EvalFn(message, client); addCallbackVar.invoke(loadFn); break; case "eldoc": case "info": String symbolStr = message["symbol"].ToString(); // Editors like Calva that support doc-on-hover sometimes will ask about empty strings or spaces if (symbolStr == "" || symbolStr == null || symbolStr == " ") { break; } IPersistentMap symbolMetadata = null; try { symbolMetadata = (IPersistentMap)metaVar.invoke(nsResolveVar.invoke( findNsVar.invoke(symbolVar.invoke(message["ns"].ToString())), symbolVar.invoke(symbolStr))); } catch (TypeNotFoundException) { // We'll just ignore this call if the type cannot be found. This happens sometimes. // TODO: One particular case when this happens is when querying info for a namespace. // That case should be handled separately (e.g., via `find-ns`?) } if (symbolMetadata != null) { var resultMessage = new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } } }; foreach (var entry in symbolMetadata) { if (entry.val() != null) { String keyStr = entry.key().ToString().Substring(1); String keyVal = entry.val().ToString(); if (keyStr == "arglists") { keyStr = "arglists-str"; } if (keyStr == "forms") { keyStr = "forms-str"; } resultMessage[keyStr] = new BString(keyVal); } } SendMessage(resultMessage, client); } else { SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "no-info" } } }, client); } break; case "complete": // When autoCompletionSupportEnabled is false, we don't advertise auto-completion support. // some editors seem to ignore this and request anyway, so we return an unknown op message. if (!autoCompletionSupportEnabled) { SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "error", "unknown-op" } } }, client); break; } Namespace ns = Namespace.find(Symbol.create(message["ns"].ToString())); var sessionBindings = _sessions[session]; var completeBindings = sessionBindings; if (ns != null) { completeBindings = completeBindings.assoc(RT.CurrentNSVar, ns); } // Make sure to eval this in the right namespace Var.pushThreadBindings(completeBindings); BList completions = (BList)completeVar.invoke(message["symbol"].ToString()); Var.popThreadBindings(); SendMessage(new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "completions", completions } }, client); break; case "classpath": BList classpath = new BList(); foreach (String p in Environment.GetEnvironmentVariable("CLOJURE_LOAD_PATH").Split(System.IO.Path.PathSeparator)) { if (p != "") { classpath.Add(Path.GetFullPath(p)); } } SendMessage(new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "classpath", classpath }, }, client); break; default: SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "error", "unknown-op" } } }, client); break; } } }
void multiFileTorrent(BDictionary info, TorrentCreationViewModel vm, List<FileInfo> files) { BList filesList = new BList(); foreach (FileInfo file in files) { BDictionary fileDictionary = new BDictionary(); fileDictionary["length"] = new BInteger(file.Length); BList pathList = new BList(); String relativePath = file.FullName.Remove(0, vm.PathRoot.Length); foreach (String elem in relativePath.Split(new char[] { '\\' })) { if (!String.IsNullOrEmpty(elem)) { pathList.Add(elem); } } fileDictionary["path"] = pathList; filesList.Add(fileDictionary); } info["name"] = new BString(vm.TorrentName); info["files"] = filesList; }
public void performance() { var stopwatch = new Stopwatch(); var count = 2 << 16; Console.WriteLine($"Count: {count}"); stopwatch.Reset(); stopwatch.Start(); { var blist = new BList<int>(); for (int i = 0; i < count; i++) { blist.Add(_random.Next()); } } stopwatch.Stop(); Console.WriteLine($"B-List - Add Last = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var blist = new BList<int>(); for (int i = 0; i < count; i++) { blist.Insert(blist.Count / 2, _random.Next()); } } stopwatch.Stop(); Console.WriteLine($"B-List - Add middle = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var blist = new BList<int>(); for (int i = 0; i < count; i++) { blist.Insert(0, _random.Next()); } } stopwatch.Stop(); Console.WriteLine($"B-List - Add First = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var list = new List<int>(); for (int i = 0; i < count; i++) { list.Add(_random.Next()); } } stopwatch.Stop(); Console.WriteLine($"List - Add Last = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var list = new List<int>(); for (int i = 0; i < count; i++) { list.Insert(list.Count / 2, _random.Next()); } } stopwatch.Stop(); Console.WriteLine($"List - Add middle = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var list = new List<int>(); for (int i = 0; i < count; i++) { list.Insert(0, _random.Next()); } } stopwatch.Stop(); Console.WriteLine($"List - Add First = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var list = new LinkedList<int>(); for (int i = 0; i < count; i++) { list.AddFirst(_random.Next()); } } stopwatch.Stop(); Console.WriteLine($"Linked-List - Add Last = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var linkedlist = new LinkedList<int>(); var last = linkedlist.AddFirst(_random.Next()); for (int i = 0; i < count; i++) { last = ((i & 1) == 1 ? linkedlist.AddAfter(last, _random.Next()) : linkedlist.AddBefore(last, _random.Next())); } } stopwatch.Stop(); Console.WriteLine($"Linked-List - Add middle = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); stopwatch.Reset(); stopwatch.Start(); { var list = new LinkedList<int>(); for (int i = 0; i < count; i++) { list.AddLast(_random.Next()); } } stopwatch.Stop(); Console.WriteLine($"Linked-List - Add First = {stopwatch.Elapsed.TotalMilliseconds:0.0}ms"); }
public void given_empty_blist_when_elements_are_added_individually_then_blist_indexer_should_return_elements() { var count = 1024; var expected = new int[count].Select(_ => _random.Next()).ToArray(); var blist = new BList<int>(); foreach (var item in expected) blist.Add(item); for (int i = 0; i < count; i++) { Assert.That(expected[i], Is.EqualTo(blist[i])); } }
given_existing_blist_when_elements_are_replaced_in_middle_then_blist_iterator_should_return_correct_latest_elements () { var initial = new int[1024].Select(_ => _random.Next()).ToArray(); var replacement = new int[256].Select(_ => _random.Next()).ToArray(); var expected = initial.Take(256).Concat(replacement).Concat(initial.Skip(512)).ToArray(); var blist = new BList<int>(); foreach (var item in initial) blist.Add(item); CollectionAssert.AreEqual(initial, blist); for (int i = 0; i < 256; i++) blist[256 + i] = replacement[i]; CollectionAssert.AreEqual(expected, blist); }
public void given_blist_with_one_element_when_two_inserted_at_index_zero_then_3rd_element_should_not_be_null() { var blist = new BList<string>(); blist.Add("Foo"); blist.InsertRange(new string[] {"Hello", "World"}, 0); Assert.That(blist.Count, Is.EqualTo(3)); Assert.That(blist[0], Is.EqualTo("Hello")); Assert.That(blist[1], Is.EqualTo("World")); Assert.That(blist[2], Is.EqualTo("Foo")); }
given_existing_blist_when_elements_are_inserted_in_middle_then_blist_iterator_should_return_correct_latest_elements () { var initial = new int[768].Select(_ => _random.Next()).ToArray(); var inserts = new int[256].Select(_ => _random.Next()).ToArray(); var expected = initial.Take(256).Concat(inserts).Concat(initial.Skip(256)).ToArray(); var blist = new BList<int>(); foreach (var item in initial) blist.Add(item); for (int i = 0; i < 256; i++) blist.Insert(256 + i, inserts[i]); Assert.That(blist.Count, Is.EqualTo(1024)); CollectionAssert.AreEqual(expected, blist); }
given_existing_blist_when_elements_are_removed_by_element_then_blist_iterator_should_return_correct_elements () { var initial = new int[512].Select(_ => _random.Next()).ToArray(); var expected = initial.Skip(32).ToArray(); var blist = new BList<int>(); foreach (var item in initial) blist.Add(item); for (int i = 0; i < 32; i++) { blist.Remove(initial[i]); } Assert.That(blist.Count, Is.EqualTo(480)); CollectionAssert.AreEqual(expected, blist); }
public static BList DecodeList(BencodeStream stream, Encoding encoding) { if (stream == null) throw new ArgumentNullException("stream"); if (encoding == null) throw new ArgumentNullException("encoding"); if (stream.Length < 2) throw new BencodeDecodingException<BList>("Minimum valid length is 2 (an empty list: 'le')", stream.Position); // Lists must start with 'l' if (stream.ReadChar() != 'l') throw new BencodeDecodingException<BList>(string.Format("Must begin with 'l' but began with '{0}'.", stream.ReadPreviousChar()), stream.Position); var list = new BList(); // Loop until next character is the end character 'e' or end of stream while (stream.Peek() != 'e' && stream.Peek() != -1) { // Decode next object in stream var bObject = Decode(stream, encoding); if (bObject == null) throw new BencodeDecodingException<BList>(string.Format("Invalid object beginning with '{0}'", stream.PeekChar()), stream.Position); list.Add(bObject); } if (stream.ReadChar() != 'e') throw new BencodeDecodingException<BList>("Missing end character 'e'.", stream.Position); return list; }