Move tests, bench and codegen deps to sub-package

Closes #225, #226.

This removes the codegen build dependency of the string_cache crate,
thereby minimizing dep for users that don't need codegen.

To allow the now external integration tests and benchmarks to test the
same things, public Atom::is_(static|dynamic|inline) -> bool methods
were also added.

Author: dekellum

.travis.yml

@@ -9,6 +9,6 @@ os:
   - linux
 script:
   - cargo build
-  - "if [ $TRAVIS_RUST_VERSION = nightly ]; then cargo test --features unstable; fi"
-  - cargo test
-  - "cd string-cache-codegen/ && cargo build && cd .."
+  - cargo test --all
+  - "cd string-cache-codegen && cargo build && cd .."
+  - "if [ $TRAVIS_RUST_VERSION = nightly ]; then cd integration-tests && cargo test --features unstable && cd ..; fi"

Cargo.toml

@@ -6,7 +6,6 @@ description = "A string interning library for Rust, developed as part of the Ser
 license = "MIT / Apache-2.0"
 repository = "https://github.com/servo/string-cache"
 documentation = "https://docs.rs/string_cache/"
-build = "build.rs"
 
 # Do not `exclude` ./string-cache-codegen because we want to include
 # ./string-cache-codegen/shared.rs, and `include` is a pain to use
@@ -17,10 +16,6 @@ build = "build.rs"
 [lib]
 name = "string_cache"
 
-[features]
-# Use unstable features to optimize space and time (memory and CPU usage).
-unstable = []
-
 [dependencies]
 precomputed-hash = "0.1"
 lazy_static = "1"
@@ -29,13 +24,12 @@ phf_shared = "0.8"
 new_debug_unreachable = "1.0"
 string_cache_shared = {path = "./shared", version = "0.3"}
 
-[dev-dependencies]
-rand = "0.4"
-string_cache_codegen = { version = "0.4", path = "./string-cache-codegen" }
-
-[build-dependencies]
-string_cache_codegen = { version = "0.4", path = "./string-cache-codegen" }
-
 [[test]]
 name = "small-stack"
 harness = false
+
+[workspace]
+members = [
+    "string-cache-codegen",
+    "integration-tests",
+]

integration-tests/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "integration_tests"
+version = "0.0.1"
+authors = [ "The Servo Project Developers" ]
+build = "build.rs"
+publish = false
+
+[lib]
+doctest = false
+test = true
+
+[features]
+
+# Use unstable features to optimize space and time (memory and CPU usage).
+unstable = []
+
+[dependencies]
+string_cache = { version = "0.7", path = ".." }
+
+[dev-dependencies]
+rand = "0.4"
+string_cache_codegen = { version = "0.4", path = "../string-cache-codegen" }
+
+[build-dependencies]
+string_cache_codegen = { version = "0.4", path = "../string-cache-codegen" }

build.rs integration-tests/build.rsbuild.rs renamed to integration-tests/build.rs

@@ -4,7 +4,7 @@ use std::env;
 use std::path::Path;
 
 fn main() {
-    string_cache_codegen::AtomType::new("atom::tests::TestAtom", "test_atom!")
+    string_cache_codegen::AtomType::new("TestAtom", "test_atom!")
         .atoms(&[
             "a", "b", "address", "area", "body", "font-weight", "br", "html", "head", "id",
         ])

src/bench.rs integration-tests/src/bench.rssrc/bench.rs renamed to integration-tests/src/bench.rs

@@ -26,23 +26,20 @@ Furthermore, a large part of the point of interning is to make strings small
 and cheap to move around, which isn't reflected in these tests.
 
 */
+use crate::TestAtom;
 
-use atom::tests::TestAtom;
 use test::{Bencher, black_box};
 
 // Just shorthand
 fn mk(x: &str) -> TestAtom {
     TestAtom::from(x)
 }
 
-macro_rules! check_type (($name:ident, $x:expr, $p:pat) => (
+macro_rules! check_type (($name:ident, $x:expr) => (
     // NB: "cargo bench" does not run these!
     #[test]
     fn $name() {
-        match unsafe { $x.unpack() } {
-            $p => (),
-            _ => panic!("atom has wrong type"),
-        }
+        assert!($x, "atom has wrong type");
     }
 ));
 
@@ -62,12 +59,12 @@ macro_rules! bench_tiny_op (($name:ident, $op:ident, $ctor_x:expr, $ctor_y:expr)
 ));
 
 macro_rules! bench_one (
-    (x_static   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Static(..)););
-    (x_inline   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Inline(..)););
-    (x_dynamic  $x:expr, $y:expr) => (check_type!(check_type_x, $x, Dynamic(..)););
-    (y_static   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Static(..)););
-    (y_inline   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Inline(..)););
-    (y_dynamic  $x:expr, $y:expr) => (check_type!(check_type_y, $y, Dynamic(..)););
+    (x_static   $x:expr, $y:expr) => (check_type!(check_type_x, $x.is_static()););
+    (x_inline   $x:expr, $y:expr) => (check_type!(check_type_x, $x.is_inline()););
+    (x_dynamic  $x:expr, $y:expr) => (check_type!(check_type_x, $x.is_dynamic()););
+    (y_static   $x:expr, $y:expr) => (check_type!(check_type_y, $y.is_static()););
+    (y_inline   $x:expr, $y:expr) => (check_type!(check_type_y, $y.is_inline()););
+    (y_dynamic  $x:expr, $y:expr) => (check_type!(check_type_y, $y.is_dynamic()););
     (is_static  $x:expr, $y:expr) => (bench_one!(x_static  $x, $y); bench_one!(y_static  $x, $y););
     (is_inline  $x:expr, $y:expr) => (bench_one!(x_inline  $x, $y); bench_one!(y_inline  $x, $y););
     (is_dynamic $x:expr, $y:expr) => (bench_one!(x_dynamic $x, $y); bench_one!(y_dynamic $x, $y););
@@ -134,8 +131,7 @@ macro_rules! bench_all (
             use std::string::ToString;
             use std::iter::repeat;
 
-            use atom::tests::TestAtom;
-            use atom::UnpackedAtom::{Static, Inline, Dynamic};
+            use crate::TestAtom;
 
             use super::mk;