Split (1)

test · 334 rows

repo string	pull_number int64	instance_id string	issue_numbers list	base_commit string	patch string	test_patch string	problem_statement string	hints_text string	created_at timestamp[s]	language string	label string
servo/rust-url	138	servo__rust-url-138	[ "116" ]	c156810a735d38c9a8e14137395bc7a3a69916a2	diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "url" -version = "0.4.0" +version = "0.5.0" authors = [ "Simon Sapin <simon.sapin@exyr.org>" ] description = "URL library for Rust, based on the WHATWG URL Standard" diff --git a/src/host.rs b/src/host.rs ---...	diff --git a/src/tests.rs b/src/tests.rs --- a/src/tests.rs +++ b/src/tests.rs @@ -8,6 +8,7 @@ use std::char; +use std::net::{Ipv4Addr, Ipv6Addr}; use super::{UrlParser, Url, SchemeData, RelativeSchemeData, Host}; @@ -347,3 +348,21 @@ fn relative_scheme_data_equality() { let b: Url = url("http://foo.com/...	Invalid IPv4 addresses are not rejected https://github.com/w3c/web-platform-tests/blob/11f3aee19205a2ae97efa1cbeb211a2395192ea8/url/urltestdata.txt#L325	I believe this test does not match the current spec, but in this case I think the spec should be changed. Spec issue: https://www.w3.org/Bugs/Public/show_bug.cgi?id=26431 Spec has been resolved	2015-11-20T15:45:55	rust	Easy
hyperium/h2	202	hyperium__h2-202	[ "154" ]	26e7a2d4165d500ee8426a10d2919e40663b4160	diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -51,7 +51,7 @@ Next, add this to your crate: ```rust extern crate h2; -use h2::server::Server; +use h2::server::Connection; fn main() { // ... diff --git a/examples/akamai.rs b/examples/akamai.rs --- a/examples/akamai.rs +++ b/examples/ak...	diff --git a/tests/client_request.rs b/tests/client_request.rs --- a/tests/client_request.rs +++ b/tests/client_request.rs @@ -13,7 +13,7 @@ fn handshake() { .write(SETTINGS_ACK) .build(); - let (_, h2) = Client::handshake(mock).wait().unwrap(); + let (_, h2) = client::handshake(mock).wait().u...	Rename `server::Server` -> `Accept` or `Listener` This type is mostly used to acquire new H2 streams. This is fairly low priority, but I thought I would propose the change to see what others thought about it.	I'm on the fence about this. Does @olix0r have any thoughts? i think `Server` and `Client` should be equivalent... So if we're reserving `Client` for something higher up the stack, I think we should save `Server` as well. I think either `Accept` or `Listener` is fine (and I'd look to the client side to determine how t...	2017-12-22T04:31:18	rust	Hard
servo/rust-url	125	servo__rust-url-125	[ "124" ]	122f5daa95c697acd55dc4d827ee5ef709236ed3	diff --git a/src/parser.rs b/src/parser.rs --- a/src/parser.rs +++ b/src/parser.rs @@ -7,6 +7,7 @@ // except according to those terms. use std::ascii::AsciiExt; +use std::cmp::max; use std::error::Error; use std::fmt::{self, Formatter}; @@ -284,7 +285,7 @@ fn parse_relative_url<'a>(input: &'a str, scheme: Strin...	diff --git a/src/tests.rs b/src/tests.rs --- a/src/tests.rs +++ b/src/tests.rs @@ -291,3 +291,13 @@ fn new_directory_paths() { fn from_str() { assert!("http://testing.com/this".parse::<Url>().is_ok()); } + +#[test] +fn issue_124() { + let url: Url = "file:a".parse().unwrap(); + assert_eq!(url.path().unwrap...	Integer Overflow on odd `file` URL This code: ``` rust "file:...".parse::<Url>(); ``` will yield this error: ``` test tests::bad_file_url ... FAILED failures: ---- tests::bad_file_url stdout ---- thread 'tests::bad_file_url' panicked at 'arithmetic operation overflowed', src/parser.rs:287 failures: ...		2015-08-10T23:31:57	rust	Easy
hyperium/h2	140	hyperium__h2-140	[ "82" ]	431442735d4509f65d490733bc1a968e92162f80	diff --git a/src/proto/streams/flow_control.rs b/src/proto/streams/flow_control.rs --- a/src/proto/streams/flow_control.rs +++ b/src/proto/streams/flow_control.rs @@ -126,8 +126,10 @@ impl FlowControl { /// This is called after receiving a SETTINGS frame with a lower /// INITIAL_WINDOW_SIZE value. pub fn...	diff --git a/tests/flow_control.rs b/tests/flow_control.rs --- a/tests/flow_control.rs +++ b/tests/flow_control.rs @@ -532,17 +532,16 @@ fn recv_window_update_on_stream_closed_by_data_frame() { // Send a data frame, this will also close the connection stream.send_data("hello".into(), true).unw...	Receiving a SETTINGS frame that reduces window size causes queued streams to panic This test panics. This may be resolved by #79 ```rust #[test] fn something_funky() { let _ = ::env_logger::init(); let (io, srv) = mock::new(); let h2 = Client::handshake(io).unwrap() .and_then(\|mut h2\| { ...		2017-10-06T19:27:19	rust	Hard
servo/rust-url	517	servo__rust-url-517	[ "483" ]	695351be29b015a29f39f55e44f4b88a947b3844	diff --git a/.travis.yml b/.travis.yml --- a/.travis.yml +++ b/.travis.yml @@ -1,28 +1,12 @@ language: rust +script: cargo test --all-features --all jobs: include: - - rust: 1.17.0 - install: - # --precise requires Cargo.lock to already exist - - cargo update - # getopts is only used in tests. Its v...	diff --git a/data-url/tests/wpt.rs b/data-url/tests/wpt.rs --- a/data-url/tests/wpt.rs +++ b/data-url/tests/wpt.rs @@ -1,6 +1,7 @@ extern crate data_url; extern crate rustc_test; -#[macro_use] extern crate serde; +#[macro_use] +extern crate serde; extern crate serde_json; fn run_data_url(input: String, expected_m...	Relaxed parsing mode Hello I understand the library tries to follow the standard as close as possible. However, there are URLs out there in the wild that exist, work and are rejected by this library as invalid. As an example, `http://canada-region-70-24-.static-apple-com.center/` (rejected because of the trailing...	The spec for [parsing hosts](https://url.spec.whatwg.org/#host-parsing) says: > 5. Let asciiDomain be the result of running domain to ASCII on domain. The spec for the [domain to ASCII](https://url.spec.whatwg.org/#concept-domain-to-ascii) algorithm says: > Let result be the result of running Unicode ToASCII w...	2019-07-15T19:34:49	rust	Easy
shuttle-hq/synth	50	shuttle-hq__synth-50	[ "8" ]	3fa7929a1bc5a0ebe2137e65a57541cf0c25e255	diff --git a/.github/workflows/scripts/validate_mysql_gen_count.sh b/.github/workflows/scripts/validate_mysql_gen_count.sh new file mode 100644 --- /dev/null +++ b/.github/workflows/scripts/validate_mysql_gen_count.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +sum_rows_query="SELECT (SELECT count(*) FROM hospitals) + (SELECT cou...	diff --git a/synth/testing_harness/mysql/0_hospital_schema.sql b/synth/testing_harness/mysql/0_hospital_schema.sql new file mode 100644 --- /dev/null +++ b/synth/testing_harness/mysql/0_hospital_schema.sql @@ -0,0 +1,31 @@ +drop table if exists hospitals; + +create table hospitals +( + id int primary key,...	Support for mysql/mariadb Required Functionality It would be really useful for my work to be able to populate directly MySQL/MariaDb databases. Something like: ```sh synth generate tpch --to mysql://user:pass@localhost:3066/mydbname ``` Proposed Solution Use case PostgreSQL or MongoDb are ...	Hey thanks for this. I will write a plan for implementation shortly. There are a few pre-requisites that need to be completed first. The APIs which define the integrations (PG, Mongo and now MySQL/MariaDB) need to change in a breaking way. We have an internal issue for this and all this will be made public as soon ...	2021-07-14T00:15:20	rust	Hard
sunng87/handlebars-rust	263	sunng87__handlebars-rust-263	[ "260" ]	75bd65de453a8f54ec10bef885e1e4ae02ab0887	diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml @@ -25,7 +25,7 @@ quick-error = "1.0.0" pest = "2.1.0" pest_derive = "2.1.0" serde = "1.0.0" -serde_json = "1.0.0" +serde_json = "1.0.39" regex = "1.0.3" lazy_static = "1.0.0" walkdir = { version = "2.2.3", optional = true } diff --git a/src/c...	diff --git a/tests/block_context.rs b/tests/block_context.rs new file mode 100644 --- /dev/null +++ b/tests/block_context.rs @@ -0,0 +1,34 @@ +use handlebars::Handlebars; +use serde_json::json; + +#[test] +fn test_partial_with_blocks() { + let hbs = Handlebars::new(); + + let data = json!({ + "a": [ + ...	Block parameters can't be used as context for partials This test case fails: ```rust #[test] fn test_partial_with_blocks() { let hbs = Handlebars::new(); let data = json!({ "a": [ {"b": 1}, {"b": 2}, ], }); let template = "{{#*inline \"test\"}}{{b...	This is impacting me right now on 2.0.0-beta.2. I'd be happy to pick up the work, but I wanted to first log it as an issue. If you have any intuition as to what the issue may be, feel free to point me there. Thanks! If it works on handlebars.js, it's something we expected to support. The context issue is usually qu...	2019-04-26T15:56:54	rust	Hard
servo/rust-url	176	servo__rust-url-176	[ "142", "154" ]	be00f8f007ef09891328b20b7beaf41a043240c0	diff --git a/.gitignore b/.gitignore --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ -/target -/Cargo.lock +target +Cargo.lock /.cargo/config diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "url" -version = "0.5.9" -authors = [ "Simon Sapin <simon.sapin@exy...	diff --git a/tests/IdnaTest.txt b/idna/tests/IdnaTest.txt similarity index 100% rename from tests/IdnaTest.txt rename to idna/tests/IdnaTest.txt diff --git a/idna/tests/punycode.rs b/idna/tests/punycode.rs new file mode 100644 --- /dev/null +++ b/idna/tests/punycode.rs @@ -0,0 +1,65 @@ +// Copyright 2013 The rust-url d...	resolving a fragment against any scheme does not succeed These tests fail https://github.com/w3c/web-platform-tests/blob/master/url/urltestdata.txt#L346-L351 because non-relative URLs can't be constructed using a base URL. DEFAULT_ENCODE_SET doesn't percent-encode / and % I'm writing a CouchDB client crate. With Couch...	I haven’t read in details yet, sorry. (Gotta run soon.) Would https://github.com/servo/rust-url/pull/151 help? Also, some notes: - The contents of `url.path()` are percent-encoded, same as in the serialization. - The `percent_encode` function is primarily written to support the parsing algorithm at https://url.spec.w...	2016-03-02T15:47:11	rust	Hard
servo/rust-url	839	servo__rust-url-839	[ "838" ]	206d37851b9313ef3a6ecb83766d9bbc65d466be	diff --git a/url/src/parser.rs b/url/src/parser.rs --- a/url/src/parser.rs +++ b/url/src/parser.rs @@ -178,7 +178,7 @@ pub fn default_port(scheme: &str) -> Option<u16> { } } -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct Input<'i> { chars: str::Chars<'i>, } @@ -1173,7 +1173,7 @@ impl<'a> Parser<'a...	diff --git a/url/tests/unit.rs b/url/tests/unit.rs --- a/url/tests/unit.rs +++ b/url/tests/unit.rs @@ -1262,3 +1262,39 @@ fn test_authority() { "%C3%A0lex:%C3%A0lex@xn--lex-8ka.xn--p1ai.example.com" ); } + +#[test] +/// https://github.com/servo/rust-url/issues/838 +fn test_file_with_drive() { + let s1...	The program crashed after using the "join" function. - [ ] Note that this crate implements the [URL Standard](https://url.spec.whatwg.org/) not RFC 1738 or RFC 3986 Describe the bug A clear and concise description of what the bug is. Include code snippets if possible. This is the version of url: ```toml [d...		2023-05-30T22:02:27	rust	Easy
shuttle-hq/synth	246	shuttle-hq__synth-246	[ "235" ]	8526fe6f9c997a1a25697375ca6dcb6c29c16927	diff --git a/.github/workflows/scripts/validate_mysql_gen_count.sh b/.github/workflows/scripts/validate_mysql_gen_count.sh deleted file mode 100644 --- a/.github/workflows/scripts/validate_mysql_gen_count.sh +++ /dev/null @@ -1,8 +0,0 @@ -#!/bin/bash - -sum_rows_query="SELECT (SELECT count(*) FROM hospitals) + (SELECT...	diff --git a/synth/testing_harness/mongodb/.env b/synth/testing_harness/mongodb/.env new file mode 100644 --- /dev/null +++ b/synth/testing_harness/mongodb/.env @@ -0,0 +1,2 @@ +PORT=${PORT:=27017} +NAME=mongo-synth-harness diff --git a/synth/testing_harness/mongodb/.gitignore b/synth/testing_harness/mongodb/.gitignore...	Improvement: align CI with test harnesses Details In #231 the CI is made to use the same script as the local testing harness for postgres integration. The idea is to keep to two from becoming out of synth and to make it easy to perform local e2e testing. The same alignment should happen for: - [x] mysql (`synt...		2021-11-10T08:58:25	rust	Hard
hyperium/h2	661	hyperium__h2-661	[ "628" ]	73bea23e9b6967cc9699918b8965e0fd87e8ae53	diff --git a/src/proto/streams/prioritize.rs b/src/proto/streams/prioritize.rs --- a/src/proto/streams/prioritize.rs +++ b/src/proto/streams/prioritize.rs @@ -323,9 +323,11 @@ impl Prioritize { /// connection pub fn reclaim_all_capacity(&mut self, stream: &mut store::Ptr, counts: &mut Counts) { let a...	diff --git a/tests/h2-tests/tests/flow_control.rs b/tests/h2-tests/tests/flow_control.rs --- a/tests/h2-tests/tests/flow_control.rs +++ b/tests/h2-tests/tests/flow_control.rs @@ -1797,3 +1797,64 @@ async fn max_send_buffer_size_poll_capacity_wakes_task() { join(srv, client).await; } + +#[tokio::test] +async fn ...	poll_capacity spuriously returns Ready(Some(0)) Sometimes, under active IO poll_capacity returns Poll(Ready(Some(0))). In this situation there is not much caller can do to wait for the capacity becomes available. It appears to be a concurrency/timing issue - my reconstruction of the events hints that it can happe...	Hello! Is there anybody here? Any thoughts or comments will be appreciated. I believe the source code even has a TODO comment about this spurious return. I don't know why it occurs, but would welcome investigation! The summary provides one real scenario how this can happen. We have been running the code with the fix...	2023-02-17T01:04:48	rust	Easy
servo/rust-url	748	servo__rust-url-748	[ "746" ]	474560dee7c5daf59831b83a489aef36634caccc	diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -2,7 +2,7 @@ name: Coverage on: push: - branches: ['master'] + branches: ["master"] pull_request: jobs: @@ -16,9 +16,9 @@ jobs: toolchain: st...	diff --git a/data-url/tests/wpt.rs b/data-url/tests/wpt.rs --- a/data-url/tests/wpt.rs +++ b/data-url/tests/wpt.rs @@ -1,3 +1,5 @@ +use tester as test; + #[macro_use] extern crate serde; @@ -32,7 +34,7 @@ fn run_data_url( fn collect_data_url<F>(add_test: &mut F) where - F: FnMut(String, bool, rustc_test::Tes...	Remove `rustc-test` dev dependency This dependency is causing some trouble: a) it has not been updated in a long time b) it depends on old versions of `term` (which depends on an old version of `winapi`) c) it depends on `term`: `term` is unmaintained d) it depends on a very old version of `time` e) id depends o...	This involves rewriting the testing frameworks used in the `idna` and `data-url`. I'll give this a shot today.	2022-01-28T14:51:51	rust	Easy
hyperium/h2	173	hyperium__h2-173	[ "36" ]	05abb686cf09f98c260ecbe1c1ef396358067756	diff --git a/src/codec/error.rs b/src/codec/error.rs --- a/src/codec/error.rs +++ b/src/codec/error.rs @@ -44,6 +44,9 @@ pub enum UserError { /// /// A new connection is needed. OverflowedStreamId, + + /// Illegal headers, such as connection-specific headers. + MalformedHeaders, } // ===== impl...	diff --git a/tests/client_request.rs b/tests/client_request.rs --- a/tests/client_request.rs +++ b/tests/client_request.rs @@ -281,6 +281,43 @@ fn request_without_scheme() {} #[ignore] fn request_with_h1_version() {} +#[test] +fn request_with_connection_headers() { + let _ = ::env_logger::init(); + let (io, s...	Strip connection level header fields > Such intermediaries SHOULD also remove other connection-specific header fields, such as Keep-Alive, Proxy-Connection, Transfer-Encoding, and Upgrade, even if they are not nominated by the Connection header field. If a header frame is sent that includes a `Connection` field, it ...	Proxies should do that, not the library. The proxies need to inspect those headers. Either way, the library has to check if those headers are set and error. How so? A proxy can receive those headers, and make some decisions based on them. And then it can build some new headers, that might include the same names, for th...	2017-11-13T20:25:40	rust	Hard
servo/rust-url	351	servo__rust-url-351	[ "166" ]	37557e4ce7e5b62de0f3735c86cb371e65859603	diff --git a/idna/Cargo.toml b/idna/Cargo.toml --- a/idna/Cargo.toml +++ b/idna/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "idna" -version = "0.1.2" +version = "0.1.3" authors = ["The rust-url developers"] description = "IDNA (Internationalizing Domain Names in Applications) and Punycode." repository = "https://g...	diff --git a/idna/tests/IdnaTest.txt b/idna/tests/IdnaTest.txt --- a/idna/tests/IdnaTest.txt +++ b/idna/tests/IdnaTest.txt @@ -1,5110 +1,7848 @@ -# IdnaTest.txt -# Date: 2016-06-16, 13:36:31 GMT -# © 2016 Unicode®, Inc. -# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other cou...	Panic when parsing a `.` in file URLs Parsing the url `file://./foo` will cause rust-url to panic, for example: ``` rust let _url = url::Url::parse("file://./foo"); ``` yields: ``` thread '<main>' panicked at 'a non-empty list of numbers', ../src/libcore/option.rs:335 stack backtrace: 1: 0x7fda97eb0f40 - sys:...	After a quick `git bisect` it looks like it doesn't panic prior to fee35ca This lead me to find "interesting" behavior that may or may not be a bug: #171. I’m waiting to hear from Valentin. @alexcrichton Is this blocking anything? If so, we can land a work around in the meantime. Ah no this isn't blocking anything o...	2017-05-29T22:02:47	rust	Hard
servo/rust-url	321	servo__rust-url-321	[ "302" ]	cb8330d4bddf82518196e4a28b98785908019dfb	diff --git a/src/origin.rs b/src/origin.rs --- a/src/origin.rs +++ b/src/origin.rs @@ -50,7 +50,7 @@ pub fn url_origin(url: &Url) -> Origin { /// the URL does not have the same origin as any other URL. /// /// For more information see https://url.spec.whatwg.org/#origin -#[derive(PartialEq, Eq, Clone, Debug)] +#[d...	diff --git a/tests/unit.rs b/tests/unit.rs --- a/tests/unit.rs +++ b/tests/unit.rs @@ -372,3 +372,45 @@ fn define_encode_set_scopes() { m::test(); } + +#[test] +/// https://github.com/servo/rust-url/issues/302 +fn test_origin_hash() { + use std::hash::{Hash,Hasher}; + use std::collections::hash_map::Defau...	Implement `Hash` for `Origin` Seems like this could reasonable be used as a key, and `Hash` is a trait we implement eagerly.		2017-05-05T11:43:02	rust	Hard
servo/rust-url	187	servo__rust-url-187	[ "25", "61" ]	df3dcd6054ac5fc7b9cab2ae0da5fedc41ff7b71	diff --git a/src/lib.rs b/src/lib.rs --- a/src/lib.rs +++ b/src/lib.rs @@ -266,6 +266,7 @@ impl Url { /// Methods of the `Url` struct assume a number of invariants. /// This checks each of these invariants and panic if one is not met. /// This is for testing rust-url itself. + #[doc(hidden)] pub ...	diff --git a/tests/unit.rs b/tests/unit.rs --- a/tests/unit.rs +++ b/tests/unit.rs @@ -233,3 +233,29 @@ fn test_form_serialize() { .finish(); assert_eq!(encoded, "foo=%C3%A9%26&bar=&foo=%23"); } + +#[test] +/// https://github.com/servo/rust-url/issues/25 +fn issue_25() { + let filename = if cfg!(windo...	Cannot parse usernames in path urls. In rust-postgres, there's a test that generates a url like so: ``` rust let mut url = Url::from_file_path(&Path::new(unix_socket_directory)).unwrap(); *url.username_mut().unwrap() = "postgres".to_string(); url.scheme = "postgres".to_string(); ...	You are trying to parse an URL with an authority (scheme://authority), an authority must include a non-empty host. Oh wait, no, I stand corrected: ``` reg-name = *( unreserved / pct-encoded / sub-delims ) ``` FWIW ``` js new URL("postgres://postgres@/var/run/postgresql").username === "" ``` is `true` for ...	2016-04-21T08:16:41	rust	Hard
hyperium/h2	150	hyperium__h2-150	[ "106" ]	c6a233281a2123969d27591164c5603a47eb798d	diff --git a/src/client.rs b/src/client.rs --- a/src/client.rs +++ b/src/client.rs @@ -187,6 +187,18 @@ impl Builder { self } + /// Set the maximum number of concurrent streams. + /// + /// Clients can only limit the maximum number of streams that that the + /// server can initiate. See [Sec...	diff --git a/tests/client_request.rs b/tests/client_request.rs --- a/tests/client_request.rs +++ b/tests/client_request.rs @@ -148,6 +148,45 @@ fn request_stream_id_overflows() { h2.join(srv).wait().expect("wait"); } +#[test] +fn client_builder_max_concurrent_streams() { + let _ = ::env_logger::init(); + ...	Support configuration of max_concurrent_streams `server::Builder` should support `set_max_concurrent_streams(&mut self, u32)` so that a server can constrain the number of streams per client. Similarly, `client::Builder` should have this, though I _think_ a client can only configure the number of concurrent server-in...	> While we're here, `client::Builder` should probably also have a `set_push_promise_enabled(&mut self, bool)` There's `builder.enable_push(bool)`: https://github.com/carllerche/h2/blob/6ec7f38cd7378a6d99ab4300a07763ab1722dcb4/src/client.rs#L181 Looks good to me.	2017-10-10T16:43:04	rust	Hard
servo/rust-url	797	servo__rust-url-797	[ "795" ]	b22857487af7c48525d0297b9db4b61ccab96b43	diff --git a/data-url/src/lib.rs b/data-url/src/lib.rs --- a/data-url/src/lib.rs +++ b/data-url/src/lib.rs @@ -298,6 +298,7 @@ where // before this special byte if i > slice_start { write_bytes(&bytes[slice_start..i])?; + slice_start = i; } ...	diff --git a/data-url/tests/data-urls.json b/data-url/tests/data-urls.json --- a/data-url/tests/data-urls.json +++ b/data-url/tests/data-urls.json @@ -52,6 +52,24 @@ ["data:text/plain;Charset=UTF-8,%C2%B1", "text/plain;charset=UTF-8", [194, 177]], + ["data:text/plain,%", + "text/plain", + [37]], + ["da...	Corrupted data URL output from <rect style='fill:%23000000;' width='100%' height='100%'/> # Version: data-url 0.2.0 & master # Description The following data URL: ``` data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg'><rect style='fill:%23000000;' width='100%' height='100%'/></svg> ``` produces a...	I'm not sure if it is the only problem, but you need to escape the spaces and % characters in your data url. > I'm not sure if it is the only problem, but you need to escape the spaces and % characters in your data url. It's a user submitted one based on browser support. It may not be correct, but this does not exp...	2022-10-02T13:37:01	rust	Easy
servo/rust-url	510	servo__rust-url-510	[ "455" ]	04e705d476c285fd6677287a59ffa64bd566ab81	diff --git a/.travis.yml b/.travis.yml --- a/.travis.yml +++ b/.travis.yml @@ -2,7 +2,7 @@ language: rust jobs: include: - - rust: 1.17.0 + - rust: 1.24.0 install: # --precise requires Cargo.lock to already exist - cargo update @@ -11,8 +11,7 @@ jobs: - cargo update -p unicode-normalizatio...	diff --git a/tests/unit.rs b/tests/unit.rs --- a/tests/unit.rs +++ b/tests/unit.rs @@ -11,7 +11,6 @@ #[macro_use] extern crate url; -use std::ascii::AsciiExt; use std::borrow::Cow; use std::cell::{Cell, RefCell}; use std::net::{Ipv4Addr, Ipv6Addr};	Use of std::ascii::AsciiExt causes warnings std::ascii::AsciiExt has been deprecated since 1.26.0 and travis build shows warnings about them at compiling. See https://travis-ci.org/servo/rust-url/jobs/400867523 for example. I think we should replace them with inherent method calls or at least suppress the warnings.		2019-07-13T09:49:45	rust	Easy
hyperium/h2	136	hyperium__h2-136	[ "120" ]	7d1732a70d981d72c92c7d32b02b6a5cb09ef296	diff --git a/src/frame/headers.rs b/src/frame/headers.rs --- a/src/frame/headers.rs +++ b/src/frame/headers.rs @@ -211,6 +211,11 @@ impl Headers { (self.header_block.pseudo, self.header_block.fields) } + #[cfg(feature = "unstable")] + pub fn pseudo_mut(&mut self) -> &mut Pseudo { + &mut sel...	diff --git a/tests/server.rs b/tests/server.rs --- a/tests/server.rs +++ b/tests/server.rs @@ -58,3 +58,30 @@ fn serve_request() { #[test] #[ignore] fn accept_with_pending_connections_after_socket_close() {} + +#[test] +fn sent_invalid_authority() { + let _ = ::env_logger::init(); + let (io, client) = mock::ne...	panic on invalid :authority When the value of `:authority` is invalid, we get the following panic: ``` thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidUriBytes(InvalidUri(InvalidUriChar))', src/libcore/result.rs:906:4 9: core::result::unwrap_failed 10: <h2::server::Peer as h2...	Looks like this is in server, so it wouldn't be a user error. > Endpoints MUST treat a request or response that contains undefined or invalid pseudo-header fields as malformed. If we say that a `:authority` with illegal bytes is an "invalid pseudo-header", then it's a [stream error of PROTOCOL_ERROR](http://httpw...	2017-10-06T02:18:30	rust	Hard
hyperium/h2	210	hyperium__h2-210	[ "138" ]	26e7a2d4165d500ee8426a10d2919e40663b4160	diff --git a/src/proto/streams/prioritize.rs b/src/proto/streams/prioritize.rs --- a/src/proto/streams/prioritize.rs +++ b/src/proto/streams/prioritize.rs @@ -266,6 +266,27 @@ impl Prioritize { Ok(()) } + /// Reclaim all capacity assigned to the stream and re-assign it to the + /// connection + ...	diff --git a/tests/server.rs b/tests/server.rs --- a/tests/server.rs +++ b/tests/server.rs @@ -172,7 +172,7 @@ fn recv_connection_header() { } #[test] -fn sends_reset_cancel_when_body_is_dropped() { +fn sends_reset_cancel_when_req_body_is_dropped() { let _ = ::env_logger::init(); let (io, client) = mock::...	Handle `Stream` dropped before end-of-stream flag sent This is a continuation of [a comment](https://github.com/carllerche/h2/pull/109/files#r143109861). I believe that currently, if a `Stream` is dropped without sending an end-of-stream flag, nothing happens. This would cause the stream to enter a hung state.	We have to guess at the intent of the user here. - If there was a content-length set, and it's gotten to zero, then that's easy: send a 0-length EOS frame. - If there was a content-length set, and it's not at zero yet, then the stream should be reset (probably with a CANCEL code). - If no content-length was set, ...	2018-01-02T23:21:45	rust	Hard
sunng87/handlebars-rust	282	sunng87__handlebars-rust-282	[ "281" ]	f30998d8393a318b895912b3523163cd45e448fb	diff --git a/src/registry.rs b/src/registry.rs --- a/src/registry.rs +++ b/src/registry.rs @@ -57,16 +57,16 @@ pub fn no_escape(data: &str) -> String { /// The single entry point of your Handlebars templates /// /// It maintains compiled templates and registered helpers. -pub struct Registry { +pub struct Registry<'...	diff --git a/tests/data_helper.rs b/tests/data_helper.rs new file mode 100644 --- /dev/null +++ b/tests/data_helper.rs @@ -0,0 +1,29 @@ +use handlebars::*; +use serde_json::json; + +struct HelperWithBorrowedData<'a>(&'a String); + +impl<'a> HelperDef for HelperWithBorrowedData<'a> { + fn call<'_reg: '_rc, '_rc>( + ...	Attach custom data to Helper. Hi! I'm new to both rust and handlebar-rust, so I'm not quite sure if this is even possible. Say I want to create a helper that references something else: ```rust pub struct FooHelper<'a> { foo: &'a Foo, } let foo = Foo{} handlebars.register_helper("foo_helper", Box::new(...	Yes, the `'static` lifetime we were using doesn't allow borrowed runtime data in helper. I will look into if it's possible to use a proper lifetime for this case. Ideally we should be able to use borrowed data with lifetime equals to the registry.	2019-07-20T14:12:28	rust	Hard
servo/rust-url	259	servo__rust-url-259	[ "252", "254" ]	9f5efbf3ab7d1ccf4b1af9283574d70f113b2d60	diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml @@ -27,6 +27,7 @@ test = false [dev-dependencies] rustc-test = "0.1" rustc-serialize = "0.3" +serde_json = ">=0.6.1, <0.9" [features] query_encoding = ["encoding"] diff --git a/Makefile b/Makefile --- a/Makefile +++ b/Makefile @@ -1,6 +1,5 @@...	diff --git a/tests/data.rs b/tests/data.rs --- a/tests/data.rs +++ b/tests/data.rs @@ -15,6 +15,16 @@ extern crate url; use rustc_serialize::json::{self, Json}; use url::{Url, quirks}; +fn check_invariants(url: &Url) { + url.check_invariants().unwrap(); + #[cfg(feature="serde")] { + extern crate serde_...	Add faster serde serialization, sacrificing invariant-safety for speed in release mode; test that it roudtrips r? @SimonSapin <!-- Reviewable:start --> --- This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/rust-url/2...		2016-12-19T16:35:59	rust	Hard
sunng87/handlebars-rust	657	sunng87__handlebars-rust-657	[ "611", "611" ]	95a53a833174f5ef2980aca206eae1bf43c2f16e	diff --git a/src/registry.rs b/src/registry.rs --- a/src/registry.rs +++ b/src/registry.rs @@ -272,6 +272,7 @@ impl<'reg> Registry<'reg> { tpl_str.as_ref(), TemplateOptions { name: Some(name.to_owned()), + is_partial: false, prevent_indent: self...	diff --git a/tests/whitespace.rs b/tests/whitespace.rs --- a/tests/whitespace.rs +++ b/tests/whitespace.rs @@ -270,3 +270,49 @@ foo output ); } + +//regression test for #611 +#[test] +fn tag_before_eof_becomes_standalone_in_full_template() { + let input = r#"<ul> + {{#each a}} + {{!-- comment --}}...	Extra whitespace added to `each` when the `/each` isn't followed by `\n` We noticed this issues when upgrading to `4.x`. If an `/each` is not followed by a `\n` the rendered template will contain extra whitespace. This throws off formats which expect consistent whitespace. Here is a repro: ```rust #[test] f...	Thank you for reporting. I can reproduce this issue with 4.x and 5.0 beta. links for comparing with javascript version: - https://sunng87.github.io/handlebars-rust/?tpl=%3Cul%3E%0A%20%20%7B%7B%23each%20a%7D%7D%0A%20%20%20%20%3Cli%3E%7B%7Bthis%7D%7D%3C%2Fli%3E%0A%20%20%7B%7B%2Feach%7D%7D&data=%7B%22a%22%3A%20%5B1%...	2024-07-13T22:03:44	rust	Hard
hyperium/h2	556	hyperium__h2-556	[ "530" ]	61b4f8fc34709b7cdfeaf91f3a7a527105c2026b	diff --git a/src/client.rs b/src/client.rs --- a/src/client.rs +++ b/src/client.rs @@ -135,9 +135,9 @@ //! [`Builder`]: struct.Builder.html //! [`Error`]: ../struct.Error.html -use crate::codec::{Codec, RecvError, SendError, UserError}; +use crate::codec::{Codec, SendError, UserError}; use crate::frame::{Headers, ...	diff --git a/src/hpack/test/fuzz.rs b/src/hpack/test/fuzz.rs --- a/src/hpack/test/fuzz.rs +++ b/src/hpack/test/fuzz.rs @@ -8,7 +8,6 @@ use rand::{Rng, SeedableRng, StdRng}; use std::io::Cursor; -const MIN_CHUNK: usize = 16; const MAX_CHUNK: usize = 2 * 1024; #[test] @@ -36,17 +35,8 @@ fn hpack_fuzz_seeded() { ...	Redesign the h2::Error type > Yea, I think we'd need to redesign the `h2::Error` type some, so that it can include if it's a stream error, or a connection error (`GOAWAY`). Then we'd be better equipped to answer that programmatically. _Originally posted by @seanmonstar in https://github.com/hyperium/hyper/issues/250...	Once those two `error` fields are made to store a `frame::GoAway`, we can patch `Connection::take_error` to also take the last stream id out of the frame, but that raises more questions: * Do we ignore the last stream id if `(ours, theirs)` is `(_, Reason::NO_ERROR)`? * How do we represent the stream id in `proto::...	2021-08-30T14:12:36	rust	Hard
shuttle-hq/synth	357	shuttle-hq__synth-357	[ "353" ]	69b8036b85a027addd244fee4460f421eb50169b	diff --git a/Cargo.lock b/Cargo.lock --- a/Cargo.lock +++ b/Cargo.lock @@ -234,18 +234,6 @@ dependencies = [ "event-listener", ] -[[package]] -name = "async-native-tls" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e9e7a929bd34c68a82d58a4de7f86fffdaf97fb2af85016...	diff --git a/synth/testing_harness/mysql/e2e.sh b/synth/testing_harness/mysql/e2e.sh --- a/synth/testing_harness/mysql/e2e.sh +++ b/synth/testing_harness/mysql/e2e.sh @@ -42,7 +42,7 @@ function load-schema() { function test-generate() { echo -e "${INFO}Test generate${NC}" load-schema --no-data \|\| { echo -e "${ER...	nix builds failing Describe the bug A clear and concise description of what the bug is. To Reproduce 1. CI tries to build for nix 2. See error ``` error: failed to run custom build command for `openssl-sys v0.9.75` Caused by: process didn't exit successfully: `/build/dummy-src/target/release/build...		2022-09-11T03:53:59	rust	Hard
kivikakk/comrak	439	kivikakk__comrak-439	[ "301" ]	3bb6d4ceb82e7c875d777899fc8c093d0d3e1fce	diff --git a/src/html.rs b/src/html.rs --- a/src/html.rs +++ b/src/html.rs @@ -725,33 +725,31 @@ impl<'o, 'c: 'o> HtmlFormatter<'o, 'c> { } } NodeValue::Text(ref literal) => { + // No sourcepos. if entering { self.escape(lit...	diff --git a/src/tests/core.rs b/src/tests/core.rs --- a/src/tests/core.rs +++ b/src/tests/core.rs @@ -495,3 +495,109 @@ fn case_insensitive_safety() { "<p><a href=\"\">a</a> <a href=\"\">b</a> <a href=\"\">c</a> <a href=\"\">d</a> <a href=\"\">e</a> <a href=\"\">f</a> <a href=\"\">g</a></p>\n", ); } + +...	Unexpected sourcepos. Hi. "sourcepos" is exactly what I was looking for. What do you think of this result? markdown ```md [AB CD](/) ``` my expected ```html <p data-sourcepos="1:1-2:6"><a data-sourcepos="1:1-2:6" href="/">AB CD</a></p> ``` comrak v0.18.0 ```html <p data-sourcepos="1:1-2:6"><a ...	That is a bit surprising! It's actually _almost_ per upstream. Here's [cmark-gfm](https://github.com/github/cmark-gfm): ```console $ cat o [AB CD](/) $ build/src/cmark-gfm o -t xml --sourcepos <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE document SYSTEM "CommonMark.dtd"> <document sourcepos="1:1-2:6" xm...	2024-07-12T08:27:19	rust	Easy
kivikakk/comrak	542	kivikakk__comrak-542	[ "503" ]	f368cfcf2da8793124b4bfd28b0e443305496cc7	diff --git a/flake.nix b/flake.nix --- a/flake.nix +++ b/flake.nix @@ -114,6 +114,8 @@ formatter = pkgs.alejandra; devShells.default = pkgs.mkShell { + name = "comrak"; + inputsFrom = builtins.attrValues self.checks.${system}; nativeBuildInputs = [ diff --git a/src/parser/auto...	diff --git a/src/tests.rs b/src/tests.rs --- a/src/tests.rs +++ b/src/tests.rs @@ -289,17 +289,16 @@ macro_rules! sourcepos { pub(crate) use sourcepos; macro_rules! ast { - (($name:tt $sp:tt)) => { - ast!(($name $sp [])) - }; - (($name:tt $sp:tt $content:tt)) => { + (($name:tt $sp:tt $( $content:...	`sourcepos` not correct for inline code It seems that the `sourcepos` for inline code is slightly off. It doesn't seem to take into account the surrounding backticks. <table> <tr> <th>Case</th> <th>Markdown</th> <th>Sourcemap</th> </tr> <tr> <td>Bold</td> <td> ```md bold ``` </td> <td> ```xml ...		2025-02-26T04:53:12	rust	Easy
servo/rust-url	198	servo__rust-url-198	[ "197" ]	d91d175186de915dba07a1c41a1225900e290b23	diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "url" -version = "1.1.0" +version = "1.1.1" authors = ["The rust-url developers"] description = "URL library for Rust, based on the WHATWG URL Standard" diff --git a/src/lib.rs b/src/lib.rs --- a/src/lib.rs +...	diff --git a/tests/unit.rs b/tests/unit.rs --- a/tests/unit.rs +++ b/tests/unit.rs @@ -259,3 +259,12 @@ fn issue_61() { assert_eq!(url.port_or_known_default(), Some(443)); url.assert_invariants(); } + +#[test] +/// https://github.com/servo/rust-url/issues/197 +fn issue_197() { + let mut url = Url::from_fi...	Panic 'index out of bounds: the len is 7 but the index is 7' This program: ``` rust extern crate url; use url::Url; fn main() { let mut url = Url::from_file_path("/").unwrap(); url.path_segments_mut().unwrap().pop_if_empty(); } ``` will panic with: ``` thread '<main>' panicked at 'index out of bounds: the ...		2016-05-25T20:34:32	rust	Hard
hyperium/h2	195	hyperium__h2-195	[ "33" ]	1552d62e7c6e1000ed4545b45603ce6fa355eb19	diff --git a/src/proto/streams/prioritize.rs b/src/proto/streams/prioritize.rs --- a/src/proto/streams/prioritize.rs +++ b/src/proto/streams/prioritize.rs @@ -238,6 +238,11 @@ impl Prioritize { stream.send_flow ); + if stream.state.is_send_closed() && stream.buffered_send_data == 0 { + ...	diff --git a/tests/stream_states.rs b/tests/stream_states.rs --- a/tests/stream_states.rs +++ b/tests/stream_states.rs @@ -666,6 +666,58 @@ fn rst_stream_max() { }); + client.join(srv).wait().expect("wait"); +} + +#[test] +fn reserved_state_recv_window_update() { + let _ = ::env_logger::init(); + ...	Accept stream WINDOW_UPDATE frames in reserved state In general, the various states in which frames can be accepted should be audited. http://httpwg.org/specs/rfc7540.html#StreamStates	I'm fairly sure this is working, as the `recv_window_update` only checks that the target stream is not idle. I guess this would require verifying that it currently works and add a test.	2017-12-19T22:18:30	rust	Hard
servo/rust-url	328	servo__rust-url-328	[ "300" ]	a44ccbe161f056bb2631161bbb9a65954cff05ec	diff --git a/src/host.rs b/src/host.rs --- a/src/host.rs +++ b/src/host.rs @@ -192,6 +192,15 @@ impl<'a> HostAndPort<&'a str> { } } +impl<S: AsRef<str>> fmt::Display for HostAndPort<S> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + self.host.fmt(f)?; + f.write_str(":")?; + self....	diff --git a/tests/unit.rs b/tests/unit.rs --- a/tests/unit.rs +++ b/tests/unit.rs @@ -13,7 +13,7 @@ extern crate url; use std::borrow::Cow; use std::net::{Ipv4Addr, Ipv6Addr}; use std::path::{Path, PathBuf}; -use url::{Host, Url, form_urlencoded}; +use url::{Host, HostAndPort, Url, form_urlencoded}; #[test] fn ...	Implement `Display` for `Host` and `HostAndPort` Probably using the obvious serialization for "host:port". Looks like `HostAndPort` impl needs to be parameterized over `S: Display`.	For IPv6 addresses, using `[]` brackets is necessary to distinguish `:` within an address and `:` separating an address and port number. `Display for Host` already does this.	2017-05-07T16:39:51	rust	Hard
shuttle-hq/synth	250	shuttle-hq__synth-250	[ "191", "190" ]	db46076d72c6e1c5a54bdb29ac26b715b3adbaf5	diff --git a/.github/workflows/synth-errors.yml b/.github/workflows/synth-errors.yml new file mode 100644 --- /dev/null +++ b/.github/workflows/synth-errors.yml @@ -0,0 +1,26 @@ +name: synth-errors + +on: + push: + branches: [master] + paths: ["*/.rs", "synth/testing_harness/errors/**"] + pull_request: + b...	diff --git a/synth/testing_harness/errors/README.md b/synth/testing_harness/errors/README.md new file mode 100644 --- /dev/null +++ b/synth/testing_harness/errors/README.md @@ -0,0 +1,11 @@ +Integration Tests for Error Messages +==================================== + +This is an integration test that validates the synt...	Unhelpful error when messing up `format` generator structure Describe the bug If we miss one level of JSON nesting in `format`, we get an unhelpful error: To Reproduce Steps to reproduce the behavior: 1. Schema (if applicable) ``` { "type": "array", "length": 1, "content": { "typ...		2021-11-12T10:00:35	rust	Hard
kivikakk/comrak	41	kivikakk__comrak-41	[ "40" ]	2b7a877406b58e788e585cbb750093e7d4dc42be	diff --git a/src/entity.rs b/src/entity.rs --- a/src/entity.rs +++ b/src/entity.rs @@ -65,7 +65,7 @@ pub fn unescape(text: &[u8]) -> Option<(Vec<u8>, usize)> { } fn lookup(text: &[u8]) -> Option<&[u8]> { - let entity_str = format!("&{};", unsafe {str::from_utf8_unchecked(text) }); + let entity_str = format!("...	diff --git a/src/tests.rs b/src/tests.rs --- a/src/tests.rs +++ b/src/tests.rs @@ -515,3 +515,26 @@ fn superscript() { concat!("<p>e = mc<sup>2</sup>.</p>\n"), \|opts\| opts.ext_superscript = true); } + +#[test] +fn header_ids() { + html_opts( + concat!( + "# Hi.\n", + ...	Generation of Header ID's I suspect I may already know the answer to this question, however as I'm not really that familiar with the different markdown specs so thought I would reach out anyway. Github automatically creates header id's, for example (`id="user-content-about"`) ``` ## About // Renders <h2> ...	GitHub uses [`cmark-gfm`](https://github.com/github/cmark)/[`commonmarker`](https://github.com/gjtorikian/commonmarker); after Markdown is converted to HTML, the HTML is run through a user content stack which e.g. adds user links (like @treiff), issue links, as well as header IDs. I'll happily add an extension to co...	2017-10-16T02:22:32	rust	Easy
servo/rust-url	537	servo__rust-url-537	[ "491" ]	622d26020491aa08c5a3c10ace046b2f35274576	diff --git a/src/host.rs b/src/host.rs --- a/src/host.rs +++ b/src/host.rs @@ -24,9 +24,10 @@ pub(crate) enum HostInternal { Ipv6(Ipv6Addr), } -impl<S> From<Host<S>> for HostInternal { - fn from(host: Host<S>) -> HostInternal { +impl From<Host<String>> for HostInternal { + fn from(host: Host<String>) -> H...	diff --git a/tests/setters_tests.json b/tests/setters_tests.json --- a/tests/setters_tests.json +++ b/tests/setters_tests.json @@ -27,7 +27,7 @@ "href": "a://example.net", "new_value": "", "expected": { - "href": "a://example.net/", + "href": "a://exa...	Added fragment percent encode set for URL fragments. Hello! I noticed that the spec here defines a fragment percent encode set: https://url.spec.whatwg.org/#percent-encoded-bytes > The fragment percent-encode set is the C0 control percent-encode set and U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+006...	:umbrella: The latest upstream changes (presumably #517) made this pull request unmergeable. Please resolve the merge conflicts. Your assessment seems to be correct. I'll check upstream if the tests changed, given the tests are supposed to follow the spec and your interpretation of the spec seems correct to me. ``` th...	2019-08-02T22:21:31	rust	Easy

Subsets and Splits

Easy Difficulty Test Results

Retrieves all records labeled as 'Easy' which provides basic filtering but offers limited analytical value beyond identifying samples of a specific category.

C++ Test Results Filter

Retrieves all columns from the test dataset where the language is C++, providing basic filtered data but offering limited analytical insights beyond simple categorization.

Ruby Language Test Results

Filters and retrieves all columns from the test dataset where the language is Ruby, providing basic information about Ruby-related entries but offering limited analytical value beyond simple filtering.

PHP Test Results

Filters and retrieves all PHP-related records from the test dataset, providing basic language-specific data but offering limited analytical value beyond simple retrieval.

SQL Console for litble/Multi-Docker-Eval

Filters and retrieves all JavaScript-related entries from the test dataset, providing basic language-specific data but offering limited analytical insights beyond simple categorization.

Java Test Results

Filters and retrieves all Java-related records from the test dataset, providing basic language-specific data but offering limited analytical insights beyond simple categorization.

Rust Language Test Results

Filters and retrieves all columns from the test dataset where the language is Rust, providing basic information about Rust-related entries but offering limited analytical value beyond simple data retrieval.

Python Test Results

Filters dataset entries to show only Python-related tests, providing basic language-specific data but offering limited analytical insights beyond simple categorization.