test: add tests for getters

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ada-url"
-authors = ["Yagiz Nizipli <[email protected]>", "Daniel Lemire <[email protected]>"]
+authors = ["Yagiz Nizipli <[email protected]>", "Daniel Lemire <[email protected]>", "LongYinan <[email protected]>"]
 version = "0.1.0"
 edition = "2021"
 description = "Fast WHATWG Compliant URL parser"
@@ -9,8 +9,22 @@ repository = "https://github.com/ada-url/rust"
 license = "MIT AND APACHE-2.0"
 exclude = [".github"]
 
+[[bench]]
+name = "parse"
+path = "bench/parse.rs"
+harness = false
+
+[features]
+# pass `cpp_set_stdlib("c++")` to `cc`
+libcpp = []
+
 [dependencies]
 thiserror = "1"
 
+[dev-dependencies]
+criterion = "0.4"
+url = "2" # Used by benchmarks
+
 [build-dependencies]
 cc = { version = "1.0", features = ["parallel"] }
+link_args = "0.6"

README.md

@@ -1,2 +1,4 @@
 ## Rust bindings for Ada
 
+Fast [WHATWG specification](https://url.spec.whatwg.org) compliant URL parser for Rust.
+

bench/parse.rs

@@ -0,0 +1,44 @@
+use ada_url::Url;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+const URL: &[&str] = &[
+    "https://www.google.com/",
+    "webhp?hl=en&ictx=2&sa=X&ved=0ahUKEwil_",
+    "oSxzJj8AhVtEFkFHTHnCGQQPQgI",
+    "https://support.google.com/websearch/",
+    "?p=ws_results_help&hl=en-CA&fg=1",
+    "https://en.wikipedia.org/wiki/Dog#Roles_with_humans",
+    "https://www.tiktok.com/@aguyandagolden/video/7133277734310038830",
+    "https://business.twitter.com/en/help/troubleshooting/",
+    "how-twitter-ads-work.html?ref=web-twc-ao-gbl-adsinfo&utm_source=twc&utm_",
+    "medium=web&utm_campaign=ao&utm_content=adsinfo",
+    "https://images-na.ssl-images-amazon.com/images/I/",
+    "41Gc3C8UysL.css?AUIClients/AmazonGatewayAuiAssets",
+    "https://www.reddit.com/?after=t3_zvz1ze",
+    "https://www.reddit.com/login/?dest=https%3A%2F%2Fwww.reddit.com%2F",
+    "postgresql://other:9818274x1!!@localhost:5432/",
+    "otherdb?connect_timeout=10&application_name=myapp",
+    "http://192.168.1.1",            // ipv4
+    "http://[2606:4700:4700::1111]", // ipv6
+];
+
+fn bench_url_parse(b: &mut Criterion) {
+    b.benchmark_group("url_parse")
+        .bench_function("ada_parse", |b| {
+            b.iter(|| {
+                URL.iter().for_each(|url| {
+                    let _ = Url::parse(black_box(url), None);
+                });
+            })
+        })
+        .bench_function("servo_parse", |b| {
+            b.iter(|| {
+                URL.iter().for_each(|url| {
+                    let _ = url::Url::parse(black_box(url));
+                });
+            })
+        });
+}
+
+criterion_group!(benches, bench_url_parse);
+criterion_main!(benches);

build.rs

@@ -1,5 +1,6 @@
 use std::env;
 
+// Taken from https://github.com/Brooooooklyn/ada-url/blob/main/ada/build.rs
 fn main() {
     println!("cargo:rerun-if-changed=deps/ada.cpp");
     println!("cargo:rerun-if-changed=deps/ada.h");
@@ -16,10 +17,21 @@ fn main() {
     let compile_target_env = env::var("CARGO_CFG_TARGET_ENV").expect("CARGO_CFG_TARGET_ENV");
     if !(compile_target_os == "windows" && compile_target_env == "msvc") {
         build.compiler("clang++");
-        build.cpp_set_stdlib("c++").flag("-std=c++17");
-        println!("cargo:rustc-link-lib=c++");
+        build.flag("-std=c++17");
+        #[cfg(feature = "libcpp")]
+        {
+            build.cpp_set_stdlib("c++");
+            println!("cargo:rustc-link-lib=c++");
+        }
     } else {
         build.flag("/std:c++17").static_crt(true);
+        link_args::windows! {
+            unsafe {
+                no_default_lib(
+                    "libcmt.lib",
+                );
+            }
+        };
     }
 
     build.compile("ada");

deps/ada.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2023-05-08 12:41:03 -0400. Do not edit! */
+/* auto-generated on 2023-05-09 17:25:59 -0400. Do not edit! */
 /* begin file src/ada.cpp */
 #include "ada.h"
 /* begin file src/checkers.cpp */
@@ -14807,17 +14807,32 @@ struct ada_url_components {
   uint32_t hash_start;
 };
 
-ada_url ada_parse(const char* input) noexcept {
+ada_url ada_parse(const char* input, size_t length) noexcept {
   return new ada::result<ada::url_aggregator>(
-      ada::parse<ada::url_aggregator>(input));
+      ada::parse<ada::url_aggregator>(std::string_view(input, length)));
 }
 
-bool ada_can_parse(const char* input, const char* base) noexcept {
-  if (base == nullptr) {
-    return ada::can_parse(input);
+ada_url ada_parse_with_base(const char* input, size_t input_length,
+                            const char* base, size_t base_length) noexcept {
+  auto base_out =
+      ada::parse<ada::url_aggregator>(std::string_view(base, base_length));
+
+  if (!base_out) {
+    return new ada::result<ada::url_aggregator>(base_out);
   }
-  std::string_view sv(base);
-  return ada::can_parse(input, &sv);
+
+  return new ada::result<ada::url_aggregator>(ada::parse<ada::url_aggregator>(
+      std::string_view(input, input_length), &base_out.value()));
+}
+
+bool ada_can_parse(const char* input, size_t length) noexcept {
+  return ada::can_parse(std::string_view(input, length));
+}
+
+bool ada_can_parse_with_base(const char* input, size_t input_length,
+                             const char* base, size_t base_length) noexcept {
+  auto base_view = std::string_view(base, base_length);
+  return ada::can_parse(std::string_view(input, input_length), &base_view);
 }
 
 void ada_free(ada_url result) noexcept {
@@ -14943,81 +14958,86 @@ ada_string ada_get_protocol(ada_url result) noexcept {
   return ada_string_create(out.data(), out.length());
 }
 
-bool ada_set_href(ada_url result, const char* input) noexcept {
+bool ada_set_href(ada_url result, const char* input, size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_href(input);
+  return r->set_href(std::string_view(input, length));
 }
 
-bool ada_set_host(ada_url result, const char* input) noexcept {
+bool ada_set_host(ada_url result, const char* input, size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_host(input);
+  return r->set_host(std::string_view(input, length));
 }
 
-bool ada_set_hostname(ada_url result, const char* input) noexcept {
+bool ada_set_hostname(ada_url result, const char* input,
+                      size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_hostname(input);
+  return r->set_hostname(std::string_view(input, length));
 }
 
-bool ada_set_protocol(ada_url result, const char* input) noexcept {
+bool ada_set_protocol(ada_url result, const char* input,
+                      size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_protocol(input);
+  return r->set_protocol(std::string_view(input, length));
 }
 
-bool ada_set_username(ada_url result, const char* input) noexcept {
+bool ada_set_username(ada_url result, const char* input,
+                      size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_username(input);
+  return r->set_username(std::string_view(input, length));
 }
 
-bool ada_set_password(ada_url result, const char* input) noexcept {
+bool ada_set_password(ada_url result, const char* input,
+                      size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_password(input);
+  return r->set_password(std::string_view(input, length));
 }
 
-bool ada_set_port(ada_url result, const char* input) noexcept {
+bool ada_set_port(ada_url result, const char* input, size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_port(input);
+  return r->set_port(std::string_view(input, length));
 }
 
-bool ada_set_pathname(ada_url result, const char* input) noexcept {
+bool ada_set_pathname(ada_url result, const char* input,
+                      size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
     return false;
   }
-  return r->set_pathname(input);
+  return r->set_pathname(std::string_view(input, length));
 }
 
-void ada_set_search(ada_url result, const char* input) noexcept {
+void ada_set_search(ada_url result, const char* input, size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (r) {
-    r->set_search(input);
+    r->set_search(std::string_view(input, length));
   }
 }
 
-void ada_set_hash(ada_url result, const char* input) noexcept {
+void ada_set_hash(ada_url result, const char* input, size_t length) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (r) {
-    r->set_hash(input);
+    r->set_hash(std::string_view(input, length));
   }
 }
 

deps/ada.h

@@ -1,4 +1,4 @@
-/* auto-generated on 2023-05-08 12:41:03 -0400. Do not edit! */
+/* auto-generated on 2023-05-09 17:25:59 -0400. Do not edit! */
 /* begin file include/ada.h */
 /**
  * @file ada.h

deps/ada_c.h

@@ -9,6 +9,10 @@
 #include <stdint.h>
 #include <stddef.h>
 
+// This is a reference to ada::url_components::omitted
+// It represents "uint32_t(-1)"
+#define ada_url_omitted 0xffffffff
+
 // string that is owned by the ada_url instance
 typedef struct {
   const char* data;
@@ -36,19 +40,23 @@ typedef void* ada_url;
 
 // input should be a null terminated C string
 // you must call ada_free on the returned pointer
-ada_url ada_parse(const char* string);
+ada_url ada_parse(const char* input, size_t length);
+ada_url ada_parse_with_base(const char* input, size_t input_length,
+                            const char* base, size_t base_length);
 
 // input and base should be a null terminated C strings
-bool ada_can_parse(const char* input, const char* base);
+bool ada_can_parse(const char* input, size_t length);
+bool ada_can_parse_with_base(const char* input, size_t input_length,
+                             const char* base, size_t base_length);
 
 void ada_free(ada_url result);
+void ada_free_owned_string(ada_owned_string owned);
 
 bool ada_is_valid(ada_url result);
 
 // url_aggregator getters
 // if ada_is_valid(result)) is false, an empty string is returned
 ada_owned_string ada_get_origin(ada_url result);
-void ada_free_owned_string(ada_owned_string owned);
 ada_string ada_get_href(ada_url result);
 ada_string ada_get_username(ada_url result);
 ada_string ada_get_password(ada_url result);
@@ -63,16 +71,16 @@ ada_string ada_get_protocol(ada_url result);
 // url_aggregator setters
 // if ada_is_valid(result)) is false, the setters have no effect
 // input should be a null terminated C string
-bool ada_set_href(ada_url result, const char* input);
-bool ada_set_host(ada_url result, const char* input);
-bool ada_set_hostname(ada_url result, const char* input);
-bool ada_set_protocol(ada_url result, const char* input);
-bool ada_set_username(ada_url result, const char* input);
-bool ada_set_password(ada_url result, const char* input);
-bool ada_set_port(ada_url result, const char* input);
-bool ada_set_pathname(ada_url result, const char* input);
-void ada_set_search(ada_url result, const char* input);
-void ada_set_hash(ada_url result, const char* input);
+bool ada_set_href(ada_url result, const char* input, size_t length);
+bool ada_set_host(ada_url result, const char* input, size_t length);
+bool ada_set_hostname(ada_url result, const char* input, size_t length);
+bool ada_set_protocol(ada_url result, const char* input, size_t length);
+bool ada_set_username(ada_url result, const char* input, size_t length);
+bool ada_set_password(ada_url result, const char* input, size_t length);
+bool ada_set_port(ada_url result, const char* input, size_t length);
+bool ada_set_pathname(ada_url result, const char* input, size_t length);
+void ada_set_search(ada_url result, const char* input, size_t length);
+void ada_set_hash(ada_url result, const char* input, size_t length);
 
 // url_aggregator functions
 // if ada_is_valid(result) is false, functions below will return false