diff --git a/src/include/units/data/bitrate.h b/src/include/units/data/bitrate.h
new file mode 100644
index 00000000..711e0fff
--- /dev/null
+++ b/src/include/units/data/bitrate.h
@@ -0,0 +1,59 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/data/information.h>
+#include <units/derived_dimension.h>
+#include <units/physical/si/time.h>
+#include <units/quantity.h>
+
+namespace units::data {
+
+struct bit_per_second : unit<bit_per_second> {};
+struct dim_bitrate : derived_dimension<dim_bitrate, bit_per_second, exp<dim_information, 1>, exp<si::dim_time, -1>> {};
+
+struct kibibit_per_second : deduced_unit<kibibit_per_second, dim_bitrate, kibibit, si::second> {};
+struct mebibit_per_second : deduced_unit<mebibit_per_second, dim_bitrate, mebibit, si::second> {};
+struct gibibit_per_second : deduced_unit<gibibit_per_second, dim_bitrate, gibibit, si::second> {};
+struct tebibit_per_second : deduced_unit<tebibit_per_second, dim_bitrate, tebibit, si::second> {};
+struct pebibit_per_second : deduced_unit<pebibit_per_second, dim_bitrate, pebibit, si::second> {};
+
+template<typename T>
+concept Bitrate = QuantityOf<T, dim_bitrate>;
+
+template<Unit U, Scalar Rep = double>
+using bitrate = quantity<dim_bitrate, U, Rep>;
+
+inline namespace literals {
+
+// bits
+constexpr auto operator""_bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); }
+constexpr auto operator""_Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); }
+constexpr auto operator""_Mibps(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); }
+constexpr auto operator""_Gibps(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); }
+constexpr auto operator""_Tibps(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); }
+constexpr auto operator""_Pibps(unsigned long long l) { return bitrate<pebibit_per_second, std::int64_t>(l); }
+
+}  // namespace literals
+
+}  // namespace units::data
diff --git a/src/include/units/data/information.h b/src/include/units/data/information.h
new file mode 100644
index 00000000..4d28f47b
--- /dev/null
+++ b/src/include/units/data/information.h
@@ -0,0 +1,74 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/base_dimension.h>
+#include <units/data/prefixes.h>
+#include <units/unit.h>
+#include <units/quantity.h>
+
+namespace units::data {
+
+struct bit : named_unit<bit, "b", prefix> {};
+struct kibibit : prefixed_unit<kibibit, kibi, bit> {};
+struct mebibit : prefixed_unit<mebibit, mebi, bit> {};
+struct gibibit : prefixed_unit<gibibit, gibi, bit> {};
+struct tebibit : prefixed_unit<tebibit, tebi, bit> {};
+struct pebibit : prefixed_unit<pebibit, pebi, bit> {};
+
+struct byte : named_scaled_unit<byte, "B", prefix, ratio<8>, bit> {};
+struct kibibyte : prefixed_unit<kibibyte, kibi, byte> {};
+struct mebibyte : prefixed_unit<mebibyte, mebi, byte> {};
+struct gibibyte : prefixed_unit<gibibyte, gibi, byte> {};
+struct tebibyte : prefixed_unit<tebibyte, tebi, byte> {};
+struct pebibyte : prefixed_unit<pebibyte, pebi, byte> {};
+
+struct dim_information : base_dimension<"information", bit> {};
+
+template<typename T>
+concept Information = QuantityOf<T, dim_information>;
+
+template<Unit U, Scalar Rep = double>
+using information = quantity<dim_information, U, Rep>;
+
+inline namespace literals {
+
+// bits
+constexpr auto operator""b(unsigned long long l) { return information<bit, std::int64_t>(l); }
+constexpr auto operator""Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); }
+constexpr auto operator""Mib(unsigned long long l) { return information<mebibit, std::int64_t>(l); }
+constexpr auto operator""Gib(unsigned long long l) { return information<gibibit, std::int64_t>(l); }
+constexpr auto operator""Tib(unsigned long long l) { return information<tebibit, std::int64_t>(l); }
+constexpr auto operator""Pib(unsigned long long l) { return information<pebibit, std::int64_t>(l); }
+
+// bytes
+constexpr auto operator""B(unsigned long long l) { return information<byte, std::int64_t>(l); }
+constexpr auto operator""KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); }
+constexpr auto operator""MiB(unsigned long long l) { return information<mebibyte, std::int64_t>(l); }
+constexpr auto operator""GiB(unsigned long long l) { return information<gibibyte, std::int64_t>(l); }
+constexpr auto operator""TiB(unsigned long long l) { return information<tebibyte, std::int64_t>(l); }
+constexpr auto operator""PiB(unsigned long long l) { return information<pebibyte, std::int64_t>(l); }
+
+}  // namespace literals
+
+}  // namespace units::data
diff --git a/src/include/units/data/prefixes.h b/src/include/units/data/prefixes.h
new file mode 100644
index 00000000..827b39fa
--- /dev/null
+++ b/src/include/units/data/prefixes.h
@@ -0,0 +1,38 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/prefix.h>
+#include <ratio>
+
+namespace units::data {
+
+struct prefix : prefix_type {};
+
+struct kibi : units::prefix<kibi, prefix, "Ki", ratio<                1'024>> {};
+struct mebi : units::prefix<mebi, prefix, "Mi", ratio<            1'048'576>> {};
+struct gibi : units::prefix<gibi, prefix, "Gi", ratio<        1'073'741'824>> {};
+struct tebi : units::prefix<tebi, prefix, "Ti", ratio<    1'099'511'627'776>> {};
+struct pebi : units::prefix<pebi, prefix, "Pi", ratio<1'125'899'906'842'624>> {};
+
+}  // namespace units::si
diff --git a/src/include/units/dimension_op.h b/src/include/units/dimension_op.h
index 294de4b4..5a58c02f 100644
--- a/src/include/units/dimension_op.h
+++ b/src/include/units/dimension_op.h
@@ -199,7 +199,7 @@ struct dimension_pow_impl<derived_dimension<exp<D, 1, N>>, N> {
 
 template<DerivedDimension D, std::size_t N>
 struct dimension_pow_impl<D, N> {
-  using type = dimension_pow_impl<downcast_base<D>, N>;
+  using type = dimension_pow_impl<downcast_base_t<D>, N>::type;
 };
 
 template<typename... Es, std::size_t N>
diff --git a/src/include/units/physical/dimensions.h b/src/include/units/physical/dimensions.h
index 89a18f53..86004125 100644
--- a/src/include/units/physical/dimensions.h
+++ b/src/include/units/physical/dimensions.h
@@ -29,7 +29,7 @@
 
 namespace units {
 
-inline namespace physical {
+namespace physical {
 
 template<typename Dim, template<typename...> typename DimTemplate>
 concept DimensionOf = (Dimension<Dim> || BaseDimension<Dim>) && is_derived_from_instantiation<Dim, DimTemplate>;
@@ -39,148 +39,128 @@ concept QuantityOf = Quantity<Q> && is_derived_from_instantiation<typename Q::di
 
 // ------------------------ base dimensions -----------------------------
 
-// length
 template<Unit U>
 struct dim_length : base_dimension<"length", U> {};
 
-template<typename T>
-concept Length = QuantityOf<T, dim_length>;
-
-// mass
 template<Unit U>
 struct dim_mass : base_dimension<"mass", U> {};
 
-template<typename T>
-concept Mass = QuantityOf<T, dim_mass>;
-
-// time
 template<Unit U>
 struct dim_time : base_dimension<"time", U> {};
 
-template<typename T>
-concept Time = QuantityOf<T, dim_time>;
-
-// current
 template<Unit U>
 struct dim_current : base_dimension<"current", U> {};
 
-template<typename T>
-concept Current = QuantityOf<T, dim_current>;
-
-// temperature
 template<Unit U>
 struct dim_temperature : base_dimension<"temperature", U> {};
 
-template<typename T>
-concept Temperature = QuantityOf<T, dim_temperature>;
-
-// substance
 template<Unit U>
 struct dim_substance : base_dimension<"substance", U> {};
 
-template<typename T>
-concept Substance = QuantityOf<T, dim_substance>;
-
-// luminous intensity
 template<Unit U>
 struct dim_luminous_intensity : base_dimension<"luminous intensity", U> {};
 
-template<typename T>
-concept LuminousIntensity = QuantityOf<T, dim_luminous_intensity>;
-
 // ------------------------ derived dimensions -----------------------------
 
-// frequency
 template<typename Child, Unit U, DimensionOf<dim_time> T>
 struct dim_frequency : derived_dimension<Child, U, exp<T, -1>> {};
 
-template<typename T>
-concept Frequency = QuantityOf<T, dim_frequency>;
-
-// area
 template<typename Child, Unit U, DimensionOf<dim_length> L>
 struct dim_area : derived_dimension<Child, U, exp<L, 2>> {};
 
-template<typename T>
-concept Area = QuantityOf<T, dim_area>;
-
-// volume
 template<typename Child, Unit U, DimensionOf<dim_length> L>
 struct dim_volume : derived_dimension<Child, U, exp<L, 3>> {};
 
-template<typename T>
-concept Volume = QuantityOf<T, dim_volume>;
-
-// velocity
 template<typename Child, Unit U, DimensionOf<dim_length> L, DimensionOf<dim_time> T>
 struct dim_velocity : derived_dimension<Child, U, exp<L, 1>, exp<T, -1>> {};
 
-template<typename T>
-concept Velocity = QuantityOf<T, dim_velocity>;
-
-// acceleration
 template<typename Child, Unit U, DimensionOf<dim_length> L, DimensionOf<dim_time> T>
 struct dim_acceleration : derived_dimension<Child, U, exp<L, 1>, exp<T, -2>> {};
 
-template<typename T>
-concept Acceleration = QuantityOf<T, dim_acceleration>;
-
-// force
 template<typename Child, Unit U, DimensionOf<dim_mass> M, DimensionOf<dim_acceleration> A>
 struct dim_force : derived_dimension<Child, U, exp<M, 1>, exp<A, 1>> {};
 
-template<typename T>
-concept Force = QuantityOf<T, dim_force>;
-
-// energy
 template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_length> L>
 struct dim_energy : derived_dimension<Child, U, exp<F, 1>, exp<L, 1>> {};
 
-template<typename T>
-concept Energy = QuantityOf<T, dim_energy>;
-
-// power
 template<typename Child, Unit U, DimensionOf<dim_energy> E, DimensionOf<dim_time> T>
 struct dim_power : derived_dimension<Child, U, exp<E, 1>, exp<T, -1>> {};
 
-template<typename T>
-concept Power = QuantityOf<T, dim_power>;
-
-// voltage
 template<typename Child, Unit U, DimensionOf<dim_power> P, DimensionOf<dim_current> C>
 struct dim_voltage : derived_dimension<Child, U, exp<P, 1>, exp<C, -1>> {};
 
-template<typename T>
-concept Voltage = QuantityOf<T, dim_voltage>;
-
-// electric charge
 template<typename Child, Unit U, DimensionOf<dim_time> T, DimensionOf<dim_current> C>
 struct dim_electric_charge : derived_dimension<Child, U, exp<T, 1>, exp<C, 1>> {};
 
-template<typename T>
-concept ElectricCharge = QuantityOf<T, dim_electric_charge>;
-
-// capacitance
 template<typename Child, Unit U, DimensionOf<dim_electric_charge> C, DimensionOf<dim_voltage> V>
 struct dim_capacitance : derived_dimension<Child, U, exp<C, 1>, exp<V, -1>> {};
 
-template<typename T>
-concept Capacitance = QuantityOf<T, dim_capacitance>;
-
-// surface tension
 template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_length> L>
 struct dim_surface_tension : derived_dimension<Child, U, exp<F, 1>, exp<L, -1>> {};
 
-template<typename T>
-concept SurfaceTension = QuantityOf<T, dim_surface_tension>;
-
-// pressure
 template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_area> A>
 struct dim_pressure : derived_dimension<Child, U, exp<F, 1>, exp<A, -1>> {};
 
-template<typename T>
-concept Pressure = QuantityOf<T, dim_pressure>;
-
 }  // namespace physical
 
+template<typename T>
+concept Length = physical::QuantityOf<T, physical::dim_length>;
+
+template<typename T>
+concept Mass = physical::QuantityOf<T, physical::dim_mass>;
+
+template<typename T>
+concept Time = physical::QuantityOf<T, physical::dim_time>;
+
+template<typename T>
+concept Current = physical::QuantityOf<T, physical::dim_current>;
+
+template<typename T>
+concept Temperature = physical::QuantityOf<T, physical::dim_temperature>;
+
+template<typename T>
+concept Substance = physical::QuantityOf<T, physical::dim_substance>;
+
+template<typename T>
+concept LuminousIntensity = physical::QuantityOf<T, physical::dim_luminous_intensity>;
+
+template<typename T>
+concept Frequency = physical::QuantityOf<T, physical::dim_frequency>;
+
+template<typename T>
+concept Area = physical::QuantityOf<T, physical::dim_area>;
+
+template<typename T>
+concept Volume = physical::QuantityOf<T, physical::dim_volume>;
+
+template<typename T>
+concept Velocity = physical::QuantityOf<T, physical::dim_velocity>;
+
+template<typename T>
+concept Acceleration = physical::QuantityOf<T, physical::dim_acceleration>;
+
+template<typename T>
+concept Force = physical::QuantityOf<T, physical::dim_force>;
+
+template<typename T>
+concept Energy = physical::QuantityOf<T, physical::dim_energy>;
+
+template<typename T>
+concept Power = physical::QuantityOf<T, physical::dim_power>;
+
+template<typename T>
+concept Voltage = physical::QuantityOf<T, physical::dim_voltage>;
+
+template<typename T>
+concept ElectricCharge = physical::QuantityOf<T, physical::dim_electric_charge>;
+
+template<typename T>
+concept Capacitance = physical::QuantityOf<T, physical::dim_capacitance>;
+
+template<typename T>
+concept SurfaceTension = physical::QuantityOf<T, physical::dim_surface_tension>;
+
+template<typename T>
+concept Pressure = physical::QuantityOf<T, physical::dim_pressure>;
+
 }  // namespace units
diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt
index b448503c..2447b832 100644
--- a/test/unit_test/static/CMakeLists.txt
+++ b/test/unit_test/static/CMakeLists.txt
@@ -22,7 +22,8 @@
 
 add_library(unit_tests_static
 #    cgs_test.cpp
-#    custom_unit_test.cpp
+    custom_unit_test.cpp
+    data_test.cpp
     dimension_op_test.cpp
 #    fixed_string_test.cpp
     math_test.cpp
diff --git a/test/unit_test/static/custom_unit_test.cpp b/test/unit_test/static/custom_unit_test.cpp
index 2df947e8..54c0c056 100644
--- a/test/unit_test/static/custom_unit_test.cpp
+++ b/test/unit_test/static/custom_unit_test.cpp
@@ -20,70 +20,37 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#include <units/dimensions/voltage.h>
-#include <units/dimensions/frequency.h>
+#include <units/physical/si/voltage.h>
+#include <units/physical/si/frequency.h>
 #include <units/math.h>
 
-/* ************** DERIVED DIMENSIONS THAT INCLUDE UNITS WITH SPECIAL NAMES **************** */
-
 namespace {
 
-  struct base_dim_digital_information : units::base_dimension<"digital information", "b"> {};
+using namespace units;
+using namespace units::si;
 
-  struct digital_information : units::derived_dimension<digital_information, units::exp<base_dim_digital_information, 1>> {};
+// power spectral density
+struct sq_volt_per_hertz : unit<sq_volt_per_hertz> {};
+struct dim_power_spectral_density : derived_dimension<dim_power_spectral_density, sq_volt_per_hertz, units::exp<dim_voltage, 2>, units::exp<dim_frequency, -1>> {};
 
-  template<typename T>
-  concept DigitalInformation = units::QuantityOf<T, digital_information>;
+template<Unit U, Scalar Rep = double>
+using power_spectral_density = quantity<dim_power_spectral_density, U, Rep>;
 
-  struct data_prefix : units::prefix_type {};
+// amplitude spectral density
+struct volt_per_sqrt_hertz : unit<volt_per_sqrt_hertz> {};
+struct dim_amplitude_spectral_density : derived_dimension<dim_amplitude_spectral_density, volt_per_sqrt_hertz, units::exp<dim_voltage, 1>, units::exp<dim_frequency, -1, 2>> {};
 
-  struct kibi : units::prefix<kibi, data_prefix, units::ratio<    1'024>, "Ki"> {};
-
-  struct bit : units::named_coherent_derived_unit<bit, digital_information, "b", data_prefix> {};
-  struct kilobit : units::prefixed_derived_unit<kilobit, kibi, bit> {};
-
-  struct byte : units::named_scaled_derived_unit<byte, digital_information, "B", units::ratio<8>, data_prefix> {};
-  struct kilobyte : units::prefixed_derived_unit<kilobyte, kibi, byte> {};
-
-  inline namespace literals {
-
-    constexpr auto operator""_b(unsigned long long l) { return units::quantity<bit, std::int64_t>(l); }
-    constexpr auto operator""_Kib(unsigned long long l) { return units::quantity<kilobit, std::int64_t>(l); }
-    constexpr auto operator""_B(unsigned long long l) { return units::quantity<byte, std::int64_t>(l); }
-    constexpr auto operator""_KiB(unsigned long long l) { return units::quantity<kilobyte, std::int64_t>(l); }
-
-  }
-}
-
-namespace {
-
-  static_assert(1_B == 8_b);
-  static_assert(1024_b == 1_Kib);
-  static_assert(1024_B == 1_KiB);
-  static_assert(8 * 1024_b == 1_KiB);
-  static_assert(8 * 1_Kib == 1_KiB);
+template<Unit U, Scalar Rep = double>
+using amplitude_spectral_density = quantity<dim_amplitude_spectral_density, U, Rep>;
 
 }
 
 namespace {
 
-  using namespace units;
+static_assert(std::is_same_v<dimension_sqrt<dim_power_spectral_density>, dim_amplitude_spectral_density>);
+static_assert(std::is_same_v<dimension_pow<dim_amplitude_spectral_density, 2>, dim_power_spectral_density>);
 
-  // power spectral density
-  struct power_spectral_density : derived_dimension<power_spectral_density, units::exp<voltage, 2>, units::exp<frequency, -1>> {};
-  struct sq_volt_per_hertz : coherent_derived_unit<sq_volt_per_hertz, power_spectral_density> {};
-
-  // amplitude spectral density
-  struct amplitude_spectral_density : derived_dimension<amplitude_spectral_density, units::exp<voltage, 1>, units::exp<frequency, -1, 2>> {};
-  struct volt_per_sqrt_hertz : coherent_derived_unit<volt_per_sqrt_hertz, amplitude_spectral_density> {};
-}
-
-namespace {
-
-  static_assert(std::is_same_v<dimension_sqrt<power_spectral_density>, amplitude_spectral_density>);
-  static_assert(std::is_same_v<dimension_pow<amplitude_spectral_density, 2>, power_spectral_density>);
-
-  static_assert(std::is_same_v<decltype(pow<2>(quantity<volt_per_sqrt_hertz>(4))), decltype(quantity<sq_volt_per_hertz>(16))>);
-  static_assert(std::is_same_v<decltype(sqrt(quantity<sq_volt_per_hertz>(16))), decltype(quantity<volt_per_sqrt_hertz>(4))>);
+static_assert(std::is_same_v<decltype(pow<2>(amplitude_spectral_density<volt_per_sqrt_hertz>(4))), decltype(power_spectral_density<sq_volt_per_hertz>(16))>);
+static_assert(std::is_same_v<decltype(sqrt(power_spectral_density<sq_volt_per_hertz>(16))), decltype(amplitude_spectral_density<volt_per_sqrt_hertz>(4))>);
 
 }
diff --git a/test/unit_test/static/data_test.cpp b/test/unit_test/static/data_test.cpp
new file mode 100644
index 00000000..14b483b2
--- /dev/null
+++ b/test/unit_test/static/data_test.cpp
@@ -0,0 +1,48 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <units/data/bitrate.h>
+#include <units/data/information.h>
+
+/* ************** DERIVED DIMENSIONS THAT INCLUDE UNITS WITH SPECIAL NAMES **************** */
+
+namespace {
+
+using namespace units::data;
+
+// information
+
+static_assert(1B == 8b);
+static_assert(1024b == 1Kib);
+static_assert(1024B == 1KiB);
+static_assert(8 * 1024b == 1KiB);
+static_assert(8 * 1Kib == 1KiB);
+
+static_assert(1Kib == 1024b);
+static_assert(1Mib == 1024Kib);
+static_assert(1Gib == 1024Mib);
+static_assert(1Tib == 1024Gib);
+static_assert(1Pib == 1024Tib);
+
+// bitrate
+
+}