c++/src/kj/units-test.c++ - toolchain/capnproto - Git at Google

 // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //
 // 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.h"
 #include <kj/compat/gtest.h>
 #include <iostream>

 namespace kj {
 namespace {

 class Bytes;
 class KiB;
 class MiB;

 typedef Quantity<int, Bytes> ByteCount;
 typedef Quantity<int, KiB> KiBCount;
 typedef Quantity<int, MiB> MiBCount;

 constexpr ByteCount BYTE KJ_UNUSED = unit<ByteCount>();
 constexpr KiBCount KIB = unit<KiBCount>();
 constexpr MiBCount MIB = unit<MiBCount>();

 constexpr UnitRatio<int, Bytes, KiB> BYTES_PER_KIB KJ_UNUSED = 1024 * BYTE / KIB;
 constexpr UnitRatio<int, Bytes, MiB> BYTES_PER_MIB KJ_UNUSED = 1024 * 1024 * BYTE / MIB;
 constexpr auto KIB_PER_MIB = 1024 * KIB / MIB;

 template <typename T, typename U>
 kj::String KJ_STRINGIFY(Quantity<T, U> value) {
   return kj::str(value / unit<Quantity<T, U>>());
 }

 TEST(UnitMeasure, Basics) {
   KiBCount k = 15 * KIB;
   EXPECT_EQ(15, k / KIB);
   EXPECT_EQ(16 * KIB, k + KIB);

   k += KIB;
   k *= 2048;

   EXPECT_EQ(32 * MIB, k / KIB_PER_MIB);

   EXPECT_TRUE(2 * KIB < 4 * KIB);
   EXPECT_FALSE(8 * KIB < 4 * KIB);
 }

 template <typename T, typename U>
 static void assertSameType() {
   U u;
   T* t = &u;
   *t = 0;
 }

 TEST(UnitMeasure, AtLeastUInt) {
   assertSameType<uint8_t , AtLeastUInt< 2>>();
   assertSameType<uint8_t , AtLeastUInt< 3>>();
   assertSameType<uint8_t , AtLeastUInt< 4>>();
   assertSameType<uint8_t , AtLeastUInt< 5>>();
   assertSameType<uint8_t , AtLeastUInt< 6>>();
   assertSameType<uint8_t , AtLeastUInt< 7>>();
   assertSameType<uint8_t , AtLeastUInt< 8>>();
   assertSameType<uint16_t, AtLeastUInt< 9>>();
   assertSameType<uint16_t, AtLeastUInt<10>>();
   assertSameType<uint16_t, AtLeastUInt<13>>();
   assertSameType<uint16_t, AtLeastUInt<16>>();
   assertSameType<uint32_t, AtLeastUInt<17>>();
   assertSameType<uint32_t, AtLeastUInt<23>>();
   assertSameType<uint32_t, AtLeastUInt<24>>();
   assertSameType<uint32_t, AtLeastUInt<25>>();
   assertSameType<uint32_t, AtLeastUInt<32>>();
   assertSameType<uint64_t, AtLeastUInt<33>>();
   assertSameType<uint64_t, AtLeastUInt<40>>();
   assertSameType<uint64_t, AtLeastUInt<41>>();
   assertSameType<uint64_t, AtLeastUInt<47>>();
   assertSameType<uint64_t, AtLeastUInt<48>>();
   assertSameType<uint64_t, AtLeastUInt<52>>();
   assertSameType<uint64_t, AtLeastUInt<64>>();

   // COMPILE ERROR: assertSameType<uint64_t, AtLeastUInt<65>>();
 }

 TEST(UnitMeasure, BoundedConst) {
   // TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
   //   line restored to verify that they actually error out.

   KJ_EXPECT((bounded<456>() + bounded<123>()).unwrap() == 456 + 123);
   KJ_EXPECT((bounded<456>() - bounded<123>()).unwrap() == 456 - 123);
   KJ_EXPECT((bounded<456>() * bounded<123>()).unwrap() == 456 * 123);
   KJ_EXPECT((bounded<456>() / bounded<123>()).unwrap() == 456 / 123);
   KJ_EXPECT((bounded<456>() % bounded<123>()).unwrap() == 456 % 123);
   KJ_EXPECT((bounded<456>() << bounded<5>()).unwrap() == 456 << 5);
   KJ_EXPECT((bounded<456>() >> bounded<2>()).unwrap() == 456 >> 2);

   KJ_EXPECT(bounded<123>() == bounded<123>());
   KJ_EXPECT(bounded<123>() != bounded<456>());
   KJ_EXPECT(bounded<123>() <  bounded<456>());
   KJ_EXPECT(bounded<456>() >  bounded<123>());
   KJ_EXPECT(bounded<123>() <= bounded<456>());
   KJ_EXPECT(bounded<456>() >= bounded<123>());

   KJ_EXPECT(!(bounded<123>() == bounded<456>()));
   KJ_EXPECT(!(bounded<123>() != bounded<123>()));
   KJ_EXPECT(!(bounded<456>() <  bounded<123>()));
   KJ_EXPECT(!(bounded<123>() >  bounded<456>()));
   KJ_EXPECT(!(bounded<456>() <= bounded<123>()));
   KJ_EXPECT(!(bounded<123>() >= bounded<456>()));

   {
     uint16_t succ = unbound(bounded<12345>());
     KJ_EXPECT(succ == 12345);

     // COMPILE ERROR: uint8_t err KJ_UNUSED = unbound(bounded<12345>());
   }

   // COMPILE ERROR: auto err1 KJ_UNUSED = bounded<(0xffffffffffffffffull)>() + bounded<1>();
   // COMPILE ERROR: auto err2 KJ_UNUSED = bounded<1>() - bounded<2>();
   // COMPILE ERROR: auto err3 KJ_UNUSED = bounded<(1ull << 60)>() * bounded<(1ull << 60)>();
   // COMPILE ERROR: auto err4 KJ_UNUSED = bounded<1>() / bounded<0>();
   // COMPILE ERROR: auto err5 KJ_UNUSED = bounded<1>() % bounded<0>();
   // COMPILE ERROR: auto err6 KJ_UNUSED = bounded<1>() << bounded<64>();
   // COMPILE ERROR: auto err7 KJ_UNUSED = bounded<(1ull << 60)>() << bounded<4>();
   // COMPILE ERROR: auto err8 KJ_UNUSED = bounded<1>() >> bounded<64>();

   // COMPILE ERROR: boundedAdd<0xffffffffffffffffull, 1>();
   // COMPILE ERROR: boundedSub<1, 2>();
   // COMPILE ERROR: boundedMul<0x100000000, 0x100000000>();
   // COMPILE ERROR: boundedLShift<0x10, 60>();
 }

 template <uint value, typename T = uint>
 constexpr Bounded<value, T> boundedValue(NoInfer<T> runtimeValue = value) {
   return Bounded<value, T>(runtimeValue, unsafe);
 }

 TEST(UnitMeasure, Bounded) {
   // TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
   //   line restored to verify that they actually error out.

   KJ_EXPECT((boundedValue<456>() + boundedValue<123>()).unwrap() == 456 + 123);
   KJ_EXPECT(boundedValue<456>().subtractChecked(boundedValue<123>(), [](){}).unwrap() == 456 - 123);
   KJ_EXPECT((boundedValue<456>() * boundedValue<123>()).unwrap() == 456 * 123);
   KJ_EXPECT((boundedValue<456>() / boundedValue<123>()).unwrap() == 456 / 123);
   KJ_EXPECT((boundedValue<456>() % boundedValue<123>()).unwrap() == 456 % 123);


   {
     Bounded<123, uint8_t> succ KJ_UNUSED;
     // COMPILE ERROR: Bounded<1234, uint8_t> err KJ_UNUSED;
     // COMPILE ERROR: auto err KJ_UNUSED = boundedValue<0xffffffffull>() + boundedValue<1>();
   }

   {
     Bounded<123, uint8_t> succ1 KJ_UNUSED = boundedValue<123>();
     Bounded<123, uint8_t> succ2 KJ_UNUSED = boundedValue<122>();
     Bounded<123, uint8_t> succ3 KJ_UNUSED = boundedValue<0>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<124>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<125>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<123456>();
   }

   Bounded<123, uint8_t> foo;
   foo = boundedValue<123>();
   foo = boundedValue<122>();
   foo = boundedValue<0>();
   // COMPILE ERROR: foo = boundedValue<124>();
   // COMPILE ERROR: foo = boundedValue<125>();
   // COMPILE ERROR: foo = boundedValue<123456>();

   assertMax<122>(foo, []() {});
   // COMPILE ERROR: assertMax<123>(foo, []() {});
   // COMPILE ERROR: assertMax<124>(foo, []() {});

   assertMaxBits<6>(foo, []() {});
   // COMPILE ERROR: assertMaxBits<7>(foo, []() {});
   // COMPILE ERROR: assertMaxBits<8>(foo, []() {});

   Bounded<12, uint8_t> bar;
   // COMPILE ERROR: bar = foo;
   // COMPILE ERROR: bar = foo.assertMax<13>([]() {});
   bool caught = false;
   foo = boundedValue<13>();
   bar = foo.assertMax<12>([&]() { caught = true; });
   KJ_EXPECT(caught);

   foo = boundedValue<100>() + boundedValue<23>();
   // COMPILE ERROR: foo = boundedValue<100>() + boundedValue<24>();

   bar = boundedValue<3>() * boundedValue<4>();
   // COMPILE ERROR: bar = boundedValue<2>() * boundedValue<7>();

   foo.subtractChecked(boundedValue<122>(), []() { KJ_FAIL_EXPECT(""); });
   foo.subtractChecked(boundedValue<123>(), []() { KJ_FAIL_EXPECT(""); });
   caught = false;
   foo.subtractChecked(boundedValue<124>(), [&]() { caught = true; });
   KJ_EXPECT(caught);

   {
     Bounded<65535, uint16_t> succ1 KJ_UNUSED = bounded((uint16_t)123);
     // COMPILE ERROR: Bounded<65534, uint16_t> err KJ_UNUSED = bounded((uint16_t)123);
   }

   uint old = foo.unwrap();
   foo = foo * unit<decltype(foo)>();
   KJ_EXPECT(foo.unwrap() == old);

   {
     Bounded<1234, uint16_t> x = bounded<123>();
     uint16_t succ = unbound(x);
     KJ_EXPECT(succ == 123);

     // COMPILE ERROR: uint8_t err KJ_UNUSED = unbound(x);
   }
 }

 TEST(UnitMeasure, BoundedVsGuardedConst) {
   // TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
   //   line restored to verify that they actually error out.

   KJ_EXPECT((boundedValue<456>() + bounded<123>()).unwrap() == 456 + 123);
   KJ_EXPECT(boundedValue<456>().subtractChecked(bounded<123>(), [](){}).unwrap() == 456 - 123);
   KJ_EXPECT((boundedValue<456>() * bounded<123>()).unwrap() == 456 * 123);
   KJ_EXPECT((boundedValue<456>() / bounded<123>()).unwrap() == 456 / 123);
   KJ_EXPECT((boundedValue<456>() % bounded<123>()).unwrap() == 456 % 123);

   {
     Bounded<123, uint8_t> succ1 KJ_UNUSED = bounded<123>();
     Bounded<123, uint8_t> succ2 KJ_UNUSED = bounded<122>();
     Bounded<123, uint8_t> succ3 KJ_UNUSED = bounded<0>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<124>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<125>();
     // COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<123456>();
   }

   Bounded<123, uint8_t> foo;
   foo = bounded<123>();
   foo = bounded<122>();
   foo = bounded<0>();
   // COMPILE ERROR: foo = bounded<124>();
   // COMPILE ERROR: foo = bounded<125>();
   // COMPILE ERROR: foo = bounded<123456>();

   Bounded<16, uint8_t> bar;
   // COMPILE ERROR: bar = foo >> bounded<2>();
   bar = foo >> bounded<3>();

   // COMPILE ERROR: foo = bar << bounded<3>();
   foo = bar << bounded<2>();
 }

 TEST(UnitMeasure, BoundedRange) {
   uint expected = 0;
   for (auto i: zeroTo(bounded<10>())) {
     Bounded<10, uint8_t> value = i;
     KJ_EXPECT(unbound(value) == expected++);
   }
   KJ_EXPECT(expected == 10);

   expected = 0;
   for (auto i: zeroTo(bounded((uint8_t)10))) {
     Bounded<255, uint8_t> value = i;
     KJ_EXPECT(unbound(value) == expected++);
   }
   KJ_EXPECT(expected == 10);

   expected = 3;
   for (auto i: range(bounded((uint8_t)3), bounded((uint8_t)10))) {
     Bounded<255, uint8_t> value = i;
     KJ_EXPECT(unbound(value) == expected++);
   }
   KJ_EXPECT(expected == 10);
 }

 TEST(UnitMeasure, BoundedQuantity) {
   auto BYTES = unit<Quantity<Bounded<12345, uint16_t>, byte>>();

   uint expected = 0;
   for (auto i: zeroTo(bounded<10>() * BYTES)) {
     Quantity<Bounded<10, uint8_t>, byte> value = i;
     KJ_EXPECT(unbound(value / BYTES) == expected++);
   }
   KJ_EXPECT(expected == 10);

   expected = 0;
   for (auto i: zeroTo(bounded((uint8_t)10) * BYTES)) {
     Quantity<Bounded<255, uint8_t>, byte> value = i;
     KJ_EXPECT(unbound(value / BYTES) == expected++);
   }
   KJ_EXPECT(expected == 10);

   expected = 3;
   for (auto i: range(bounded((uint8_t)3) * BYTES, bounded((uint8_t)10) * BYTES)) {
     Quantity<Bounded<255, uint8_t>, byte> value = i;
     KJ_EXPECT(unbound(value / BYTES) == expected++);
   }
   KJ_EXPECT(expected == 10);
 }

 template <typename T>
 void assertTypeAndValue(T a, T b) { KJ_EXPECT(a == b); }

 TEST(UnitMeasure, BoundedMinMax) {
   assertTypeAndValue(bounded<5>(), kj::max(bounded<4>(), bounded<5>()));
   assertTypeAndValue(bounded<5>(), kj::max(bounded<5>(), bounded<4>()));
   assertTypeAndValue(bounded<4>(), kj::max(bounded<4>(), bounded<4>()));

   assertTypeAndValue(bounded<4>(), kj::min(bounded<4>(), bounded<5>()));
   assertTypeAndValue(bounded<4>(), kj::min(bounded<5>(), bounded<4>()));
   assertTypeAndValue(bounded<4>(), kj::min(bounded<4>(), bounded<4>()));

   typedef uint8_t t1;
   typedef uint16_t t2;

   assertTypeAndValue(boundedValue<5,t2>(3), kj::max(boundedValue<4,t2>(3), boundedValue<5,t1>(2)));
   assertTypeAndValue(boundedValue<5,t2>(3), kj::max(boundedValue<5,t1>(2), boundedValue<4,t2>(3)));
   assertTypeAndValue(boundedValue<4,t2>(3), kj::max(boundedValue<4,t2>(3), boundedValue<4,t2>(3)));

   assertTypeAndValue(boundedValue<4,t2>(2), kj::min(boundedValue<4,t2>(3), boundedValue<5,t1>(2)));
   assertTypeAndValue(boundedValue<4,t2>(2), kj::min(boundedValue<5,t1>(2), boundedValue<4,t2>(3)));
   assertTypeAndValue(boundedValue<4,t2>(3), kj::min(boundedValue<4,t2>(3), boundedValue<4,t2>(3)));

   assertTypeAndValue(boundedValue<5,t1>(4), kj::max(bounded<4>(), boundedValue<5,t1>(2)));
   assertTypeAndValue(boundedValue<5,t1>(4), kj::max(boundedValue<5,t1>(2), bounded<4>()));

   assertTypeAndValue(boundedValue<4,t1>(2), kj::min(bounded<4>(), boundedValue<5,t1>(2)));
   assertTypeAndValue(boundedValue<4,t1>(2), kj::min(boundedValue<5,t1>(2), bounded<4>()));

   // These two are degenerate cases. Currently they fail to compile but maybe they shouldn't?
 //  assertTypeAndValue(bounded<5>(), kj::max(boundedValue<4,t2>(3), bounded<5>()));
 //  assertTypeAndValue(bounded<5>(), kj::max(bounded<5>(), boundedValue<4,t2>(3)));

   assertTypeAndValue(boundedValue<4,t2>(3), kj::min(boundedValue<4,t2>(3), bounded<5>()));
   assertTypeAndValue(boundedValue<4,t2>(3), kj::min(bounded<5>(), boundedValue<4,t2>(3)));
 }

 #if !_MSC_VER  // MSVC barfs on this test and I just don't have time to care.
 KJ_TEST("compare bounded quantities of different bounds") {
   auto foo = boundedValue<12345, uint>(123) * unit<Quantity<BoundedConst<1>, byte>>();
   auto bar = boundedValue<54321, uint>(123) * unit<Quantity<BoundedConst<1>, byte>>();
   auto baz = bounded<123>() * unit<Quantity<BoundedConst<1>, byte>>();

   KJ_EXPECT(foo == foo);
   KJ_EXPECT(foo == bar);
   KJ_EXPECT(foo == baz);
   KJ_EXPECT(bar == foo);
   KJ_EXPECT(bar == bar);
   KJ_EXPECT(bar == baz);
   KJ_EXPECT(baz == foo);
   KJ_EXPECT(baz == bar);
   KJ_EXPECT(baz == baz);

   auto denom = unit<Quantity<BoundedConst<1>, int>>();

   KJ_EXPECT(foo / denom == foo / denom);
   KJ_EXPECT(foo / denom == bar / denom);
   KJ_EXPECT(foo / denom == baz / denom);
   KJ_EXPECT(bar / denom == foo / denom);
   KJ_EXPECT(bar / denom == bar / denom);
   KJ_EXPECT(bar / denom == baz / denom);
   KJ_EXPECT(baz / denom == foo / denom);
   KJ_EXPECT(baz / denom == bar / denom);
   KJ_EXPECT(baz / denom == baz / denom);
 }
 #endif

 }  // namespace
 }  // namespace kj
	// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
	// Licensed under the MIT License:
	//
	// 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.h"
	#include <kj/compat/gtest.h>
	#include <iostream>

	namespace kj {
	namespace {

	class Bytes;
	class KiB;
	class MiB;

	typedef Quantity<int, Bytes> ByteCount;
	typedef Quantity<int, KiB> KiBCount;
	typedef Quantity<int, MiB> MiBCount;

	constexpr ByteCount BYTE KJ_UNUSED = unit<ByteCount>();
	constexpr KiBCount KIB = unit<KiBCount>();
	constexpr MiBCount MIB = unit<MiBCount>();

	constexpr UnitRatio<int, Bytes, KiB> BYTES_PER_KIB KJ_UNUSED = 1024 * BYTE / KIB;
	constexpr UnitRatio<int, Bytes, MiB> BYTES_PER_MIB KJ_UNUSED = 1024 * 1024 * BYTE / MIB;
	constexpr auto KIB_PER_MIB = 1024 * KIB / MIB;

	template <typename T, typename U>
	kj::String KJ_STRINGIFY(Quantity<T, U> value) {
	return kj::str(value / unit<Quantity<T, U>>());
	}

	TEST(UnitMeasure, Basics) {
	KiBCount k = 15 * KIB;
	EXPECT_EQ(15, k / KIB);
	EXPECT_EQ(16 * KIB, k + KIB);

	k += KIB;
	k *= 2048;

	EXPECT_EQ(32 * MIB, k / KIB_PER_MIB);

	EXPECT_TRUE(2 * KIB < 4 * KIB);
	EXPECT_FALSE(8 * KIB < 4 * KIB);
	}

	template <typename T, typename U>
	static void assertSameType() {
	U u;
	T* t = &u;
	*t = 0;
	}

	TEST(UnitMeasure, AtLeastUInt) {
	assertSameType<uint8_t , AtLeastUInt< 2>>();
	assertSameType<uint8_t , AtLeastUInt< 3>>();
	assertSameType<uint8_t , AtLeastUInt< 4>>();
	assertSameType<uint8_t , AtLeastUInt< 5>>();
	assertSameType<uint8_t , AtLeastUInt< 6>>();
	assertSameType<uint8_t , AtLeastUInt< 7>>();
	assertSameType<uint8_t , AtLeastUInt< 8>>();
	assertSameType<uint16_t, AtLeastUInt< 9>>();
	assertSameType<uint16_t, AtLeastUInt<10>>();
	assertSameType<uint16_t, AtLeastUInt<13>>();
	assertSameType<uint16_t, AtLeastUInt<16>>();
	assertSameType<uint32_t, AtLeastUInt<17>>();
	assertSameType<uint32_t, AtLeastUInt<23>>();
	assertSameType<uint32_t, AtLeastUInt<24>>();
	assertSameType<uint32_t, AtLeastUInt<25>>();
	assertSameType<uint32_t, AtLeastUInt<32>>();
	assertSameType<uint64_t, AtLeastUInt<33>>();
	assertSameType<uint64_t, AtLeastUInt<40>>();
	assertSameType<uint64_t, AtLeastUInt<41>>();
	assertSameType<uint64_t, AtLeastUInt<47>>();
	assertSameType<uint64_t, AtLeastUInt<48>>();
	assertSameType<uint64_t, AtLeastUInt<52>>();
	assertSameType<uint64_t, AtLeastUInt<64>>();

	// COMPILE ERROR: assertSameType<uint64_t, AtLeastUInt<65>>();
	}

	TEST(UnitMeasure, BoundedConst) {
	// TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
	// line restored to verify that they actually error out.

	KJ_EXPECT((bounded<456>() + bounded<123>()).unwrap() == 456 + 123);
	KJ_EXPECT((bounded<456>() - bounded<123>()).unwrap() == 456 - 123);
	KJ_EXPECT((bounded<456>() * bounded<123>()).unwrap() == 456 * 123);
	KJ_EXPECT((bounded<456>() / bounded<123>()).unwrap() == 456 / 123);
	KJ_EXPECT((bounded<456>() % bounded<123>()).unwrap() == 456 % 123);
	KJ_EXPECT((bounded<456>() << bounded<5>()).unwrap() == 456 << 5);
	KJ_EXPECT((bounded<456>() >> bounded<2>()).unwrap() == 456 >> 2);

	KJ_EXPECT(bounded<123>() == bounded<123>());
	KJ_EXPECT(bounded<123>() != bounded<456>());
	KJ_EXPECT(bounded<123>() < bounded<456>());
	KJ_EXPECT(bounded<456>() > bounded<123>());
	KJ_EXPECT(bounded<123>() <= bounded<456>());
	KJ_EXPECT(bounded<456>() >= bounded<123>());

	KJ_EXPECT(!(bounded<123>() == bounded<456>()));
	KJ_EXPECT(!(bounded<123>() != bounded<123>()));
	KJ_EXPECT(!(bounded<456>() < bounded<123>()));
	KJ_EXPECT(!(bounded<123>() > bounded<456>()));
	KJ_EXPECT(!(bounded<456>() <= bounded<123>()));
	KJ_EXPECT(!(bounded<123>() >= bounded<456>()));

	{
	uint16_t succ = unbound(bounded<12345>());
	KJ_EXPECT(succ == 12345);

	// COMPILE ERROR: uint8_t err KJ_UNUSED = unbound(bounded<12345>());
	}

	// COMPILE ERROR: auto err1 KJ_UNUSED = bounded<(0xffffffffffffffffull)>() + bounded<1>();
	// COMPILE ERROR: auto err2 KJ_UNUSED = bounded<1>() - bounded<2>();
	// COMPILE ERROR: auto err3 KJ_UNUSED = bounded<(1ull << 60)>() * bounded<(1ull << 60)>();
	// COMPILE ERROR: auto err4 KJ_UNUSED = bounded<1>() / bounded<0>();
	// COMPILE ERROR: auto err5 KJ_UNUSED = bounded<1>() % bounded<0>();
	// COMPILE ERROR: auto err6 KJ_UNUSED = bounded<1>() << bounded<64>();
	// COMPILE ERROR: auto err7 KJ_UNUSED = bounded<(1ull << 60)>() << bounded<4>();
	// COMPILE ERROR: auto err8 KJ_UNUSED = bounded<1>() >> bounded<64>();

	// COMPILE ERROR: boundedAdd<0xffffffffffffffffull, 1>();
	// COMPILE ERROR: boundedSub<1, 2>();
	// COMPILE ERROR: boundedMul<0x100000000, 0x100000000>();
	// COMPILE ERROR: boundedLShift<0x10, 60>();
	}

	template <uint value, typename T = uint>
	constexpr Bounded<value, T> boundedValue(NoInfer<T> runtimeValue = value) {
	return Bounded<value, T>(runtimeValue, unsafe);
	}

	TEST(UnitMeasure, Bounded) {
	// TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
	// line restored to verify that they actually error out.

	KJ_EXPECT((boundedValue<456>() + boundedValue<123>()).unwrap() == 456 + 123);
	KJ_EXPECT(boundedValue<456>().subtractChecked(boundedValue<123>(), [](){}).unwrap() == 456 - 123);
	KJ_EXPECT((boundedValue<456>() * boundedValue<123>()).unwrap() == 456 * 123);
	KJ_EXPECT((boundedValue<456>() / boundedValue<123>()).unwrap() == 456 / 123);
	KJ_EXPECT((boundedValue<456>() % boundedValue<123>()).unwrap() == 456 % 123);


	{
	Bounded<123, uint8_t> succ KJ_UNUSED;
	// COMPILE ERROR: Bounded<1234, uint8_t> err KJ_UNUSED;
	// COMPILE ERROR: auto err KJ_UNUSED = boundedValue<0xffffffffull>() + boundedValue<1>();
	}

	{
	Bounded<123, uint8_t> succ1 KJ_UNUSED = boundedValue<123>();
	Bounded<123, uint8_t> succ2 KJ_UNUSED = boundedValue<122>();
	Bounded<123, uint8_t> succ3 KJ_UNUSED = boundedValue<0>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<124>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<125>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = boundedValue<123456>();
	}

	Bounded<123, uint8_t> foo;
	foo = boundedValue<123>();
	foo = boundedValue<122>();
	foo = boundedValue<0>();
	// COMPILE ERROR: foo = boundedValue<124>();
	// COMPILE ERROR: foo = boundedValue<125>();
	// COMPILE ERROR: foo = boundedValue<123456>();

	assertMax<122>(foo, []() {});
	// COMPILE ERROR: assertMax<123>(foo, []() {});
	// COMPILE ERROR: assertMax<124>(foo, []() {});

	assertMaxBits<6>(foo, []() {});
	// COMPILE ERROR: assertMaxBits<7>(foo, []() {});
	// COMPILE ERROR: assertMaxBits<8>(foo, []() {});

	Bounded<12, uint8_t> bar;
	// COMPILE ERROR: bar = foo;
	// COMPILE ERROR: bar = foo.assertMax<13>([]() {});
	bool caught = false;
	foo = boundedValue<13>();
	bar = foo.assertMax<12>([&]() { caught = true; });
	KJ_EXPECT(caught);

	foo = boundedValue<100>() + boundedValue<23>();
	// COMPILE ERROR: foo = boundedValue<100>() + boundedValue<24>();

	bar = boundedValue<3>() * boundedValue<4>();
	// COMPILE ERROR: bar = boundedValue<2>() * boundedValue<7>();

	foo.subtractChecked(boundedValue<122>(), []() { KJ_FAIL_EXPECT(""); });
	foo.subtractChecked(boundedValue<123>(), []() { KJ_FAIL_EXPECT(""); });
	caught = false;
	foo.subtractChecked(boundedValue<124>(), [&]() { caught = true; });
	KJ_EXPECT(caught);

	{
	Bounded<65535, uint16_t> succ1 KJ_UNUSED = bounded((uint16_t)123);
	// COMPILE ERROR: Bounded<65534, uint16_t> err KJ_UNUSED = bounded((uint16_t)123);
	}

	uint old = foo.unwrap();
	foo = foo * unit<decltype(foo)>();
	KJ_EXPECT(foo.unwrap() == old);

	{
	Bounded<1234, uint16_t> x = bounded<123>();
	uint16_t succ = unbound(x);
	KJ_EXPECT(succ == 123);

	// COMPILE ERROR: uint8_t err KJ_UNUSED = unbound(x);
	}
	}

	TEST(UnitMeasure, BoundedVsGuardedConst) {
	// TODO(someday): Some script should attempt to compile this test once with each "COMPILE ERROR"
	// line restored to verify that they actually error out.

	KJ_EXPECT((boundedValue<456>() + bounded<123>()).unwrap() == 456 + 123);
	KJ_EXPECT(boundedValue<456>().subtractChecked(bounded<123>(), [](){}).unwrap() == 456 - 123);
	KJ_EXPECT((boundedValue<456>() * bounded<123>()).unwrap() == 456 * 123);
	KJ_EXPECT((boundedValue<456>() / bounded<123>()).unwrap() == 456 / 123);
	KJ_EXPECT((boundedValue<456>() % bounded<123>()).unwrap() == 456 % 123);

	{
	Bounded<123, uint8_t> succ1 KJ_UNUSED = bounded<123>();
	Bounded<123, uint8_t> succ2 KJ_UNUSED = bounded<122>();
	Bounded<123, uint8_t> succ3 KJ_UNUSED = bounded<0>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<124>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<125>();
	// COMPILE ERROR: Bounded<123, uint8_t> err KJ_UNUSED = bounded<123456>();
	}

	Bounded<123, uint8_t> foo;
	foo = bounded<123>();
	foo = bounded<122>();
	foo = bounded<0>();
	// COMPILE ERROR: foo = bounded<124>();
	// COMPILE ERROR: foo = bounded<125>();
	// COMPILE ERROR: foo = bounded<123456>();

	Bounded<16, uint8_t> bar;
	// COMPILE ERROR: bar = foo >> bounded<2>();
	bar = foo >> bounded<3>();

	// COMPILE ERROR: foo = bar << bounded<3>();
	foo = bar << bounded<2>();
	}

	TEST(UnitMeasure, BoundedRange) {
	uint expected = 0;
	for (auto i: zeroTo(bounded<10>())) {
	Bounded<10, uint8_t> value = i;
	KJ_EXPECT(unbound(value) == expected++);
	}
	KJ_EXPECT(expected == 10);

	expected = 0;
	for (auto i: zeroTo(bounded((uint8_t)10))) {
	Bounded<255, uint8_t> value = i;
	KJ_EXPECT(unbound(value) == expected++);
	}
	KJ_EXPECT(expected == 10);

	expected = 3;
	for (auto i: range(bounded((uint8_t)3), bounded((uint8_t)10))) {
	Bounded<255, uint8_t> value = i;
	KJ_EXPECT(unbound(value) == expected++);
	}
	KJ_EXPECT(expected == 10);
	}

	TEST(UnitMeasure, BoundedQuantity) {
	auto BYTES = unit<Quantity<Bounded<12345, uint16_t>, byte>>();

	uint expected = 0;
	for (auto i: zeroTo(bounded<10>() * BYTES)) {
	Quantity<Bounded<10, uint8_t>, byte> value = i;
	KJ_EXPECT(unbound(value / BYTES) == expected++);
	}
	KJ_EXPECT(expected == 10);

	expected = 0;
	for (auto i: zeroTo(bounded((uint8_t)10) * BYTES)) {
	Quantity<Bounded<255, uint8_t>, byte> value = i;
	KJ_EXPECT(unbound(value / BYTES) == expected++);
	}
	KJ_EXPECT(expected == 10);

	expected = 3;
	for (auto i: range(bounded((uint8_t)3) * BYTES, bounded((uint8_t)10) * BYTES)) {
	Quantity<Bounded<255, uint8_t>, byte> value = i;
	KJ_EXPECT(unbound(value / BYTES) == expected++);
	}
	KJ_EXPECT(expected == 10);
	}

	template <typename T>
	void assertTypeAndValue(T a, T b) { KJ_EXPECT(a == b); }

	TEST(UnitMeasure, BoundedMinMax) {
	assertTypeAndValue(bounded<5>(), kj::max(bounded<4>(), bounded<5>()));
	assertTypeAndValue(bounded<5>(), kj::max(bounded<5>(), bounded<4>()));
	assertTypeAndValue(bounded<4>(), kj::max(bounded<4>(), bounded<4>()));

	assertTypeAndValue(bounded<4>(), kj::min(bounded<4>(), bounded<5>()));
	assertTypeAndValue(bounded<4>(), kj::min(bounded<5>(), bounded<4>()));
	assertTypeAndValue(bounded<4>(), kj::min(bounded<4>(), bounded<4>()));

	typedef uint8_t t1;
	typedef uint16_t t2;

	assertTypeAndValue(boundedValue<5,t2>(3), kj::max(boundedValue<4,t2>(3), boundedValue<5,t1>(2)));
	assertTypeAndValue(boundedValue<5,t2>(3), kj::max(boundedValue<5,t1>(2), boundedValue<4,t2>(3)));
	assertTypeAndValue(boundedValue<4,t2>(3), kj::max(boundedValue<4,t2>(3), boundedValue<4,t2>(3)));

	assertTypeAndValue(boundedValue<4,t2>(2), kj::min(boundedValue<4,t2>(3), boundedValue<5,t1>(2)));
	assertTypeAndValue(boundedValue<4,t2>(2), kj::min(boundedValue<5,t1>(2), boundedValue<4,t2>(3)));
	assertTypeAndValue(boundedValue<4,t2>(3), kj::min(boundedValue<4,t2>(3), boundedValue<4,t2>(3)));

	assertTypeAndValue(boundedValue<5,t1>(4), kj::max(bounded<4>(), boundedValue<5,t1>(2)));
	assertTypeAndValue(boundedValue<5,t1>(4), kj::max(boundedValue<5,t1>(2), bounded<4>()));

	assertTypeAndValue(boundedValue<4,t1>(2), kj::min(bounded<4>(), boundedValue<5,t1>(2)));
	assertTypeAndValue(boundedValue<4,t1>(2), kj::min(boundedValue<5,t1>(2), bounded<4>()));

	// These two are degenerate cases. Currently they fail to compile but maybe they shouldn't?
	// assertTypeAndValue(bounded<5>(), kj::max(boundedValue<4,t2>(3), bounded<5>()));
	// assertTypeAndValue(bounded<5>(), kj::max(bounded<5>(), boundedValue<4,t2>(3)));

	assertTypeAndValue(boundedValue<4,t2>(3), kj::min(boundedValue<4,t2>(3), bounded<5>()));
	assertTypeAndValue(boundedValue<4,t2>(3), kj::min(bounded<5>(), boundedValue<4,t2>(3)));
	}

	#if !_MSC_VER // MSVC barfs on this test and I just don't have time to care.
	KJ_TEST("compare bounded quantities of different bounds") {
	auto foo = boundedValue<12345, uint>(123) * unit<Quantity<BoundedConst<1>, byte>>();
	auto bar = boundedValue<54321, uint>(123) * unit<Quantity<BoundedConst<1>, byte>>();
	auto baz = bounded<123>() * unit<Quantity<BoundedConst<1>, byte>>();

	KJ_EXPECT(foo == foo);
	KJ_EXPECT(foo == bar);
	KJ_EXPECT(foo == baz);
	KJ_EXPECT(bar == foo);
	KJ_EXPECT(bar == bar);
	KJ_EXPECT(bar == baz);
	KJ_EXPECT(baz == foo);
	KJ_EXPECT(baz == bar);
	KJ_EXPECT(baz == baz);

	auto denom = unit<Quantity<BoundedConst<1>, int>>();

	KJ_EXPECT(foo / denom == foo / denom);
	KJ_EXPECT(foo / denom == bar / denom);
	KJ_EXPECT(foo / denom == baz / denom);
	KJ_EXPECT(bar / denom == foo / denom);
	KJ_EXPECT(bar / denom == bar / denom);
	KJ_EXPECT(bar / denom == baz / denom);
	KJ_EXPECT(baz / denom == foo / denom);
	KJ_EXPECT(baz / denom == bar / denom);
	KJ_EXPECT(baz / denom == baz / denom);
	}
	#endif

	} // namespace
	} // namespace kj