text: #include "test/jemalloc_test.h"
  
  static size_t get_max_size_class(void)
  {
      unsigned nlextents;
      size_t mib[4];
      size_t sz, miblen, max_size_class;
  
      sz = sizeof(unsigned);
      assert_d_eq(mallctl("arenas.nlextents", (void *)&nlextents, &sz, NULL, 0),
                  0, "Unexpected mallctl() error");
  
      miblen = sizeof(mib) / sizeof(size_t);
      assert_d_eq(mallctlnametomib("arenas.lextent.0.size", mib, &miblen), 0,
                  "Unexpected mallctlnametomib() error");
      mib[2] = nlextents - 1;
  
      sz = sizeof(size_t);
      assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz, NULL,
                               0),
                  0, "Unexpected mallctlbymib() error");
  
      return max_size_class;
  }
  
  TEST_BEGIN(test_size_classes)
  {
      size_t size_class, max_size_class;
      szind_t index, max_index;
  
      max_size_class = get_max_size_class();
      max_index = sz_size2index(max_size_class);
  
      for (index = 0, size_class = sz_index2size(index);
           index < max_index || size_class < max_size_class;
           index++, size_class = sz_index2size(index)) {
          assert_true(index < max_index,
                      "Loop conditionals should be equivalent; index=%u, "
                      "size_class=%zu (%#zx)",
                      index, size_class, size_class);
          assert_true(size_class < max_size_class,
                      "Loop conditionals should be equivalent; index=%u, "
                      "size_class=%zu (%#zx)",
                      index, size_class, size_class);
  
          assert_u_eq(index, sz_size2index(size_class),
                      "sz_size2index() does not reverse sz_index2size(): index=%u"
                      " --> size_class=%zu --> index=%u --> size_class=%zu",
                      index, size_class, sz_size2index(size_class),
                      sz_index2size(sz_size2index(size_class)));
          assert_zu_eq(
              size_class, sz_index2size(sz_size2index(size_class)),
              "sz_index2size() does not reverse sz_size2index(): index=%u"
              " --> size_class=%zu --> index=%u --> size_class=%zu",
              index, size_class, sz_size2index(size_class),
              sz_index2size(sz_size2index(size_class)));
  
          assert_u_eq(index + 1, sz_size2index(size_class + 1),
                      "Next size_class does not round up properly");
  
          assert_zu_eq(size_class,
                       (index > 0) ? sz_s2u(sz_index2size(index - 1) + 1) :
                                     sz_s2u(1),
                       "sz_s2u() does not round up to size class");
          assert_zu_eq(size_class, sz_s2u(size_class - 1),
                       "sz_s2u() does not round up to size class");
          assert_zu_eq(size_class, sz_s2u(size_class),
                       "sz_s2u() does not compute same size class");
          assert_zu_eq(sz_s2u(size_class + 1), sz_index2size(index + 1),
                       "sz_s2u() does not round up to next size class");
      }
  
      assert_u_eq(index, sz_size2index(sz_index2size(index)),
                  "sz_size2index() does not reverse sz_index2size()");
      assert_zu_eq(max_size_class, sz_index2size(sz_size2index(max_size_class)),
                   "sz_index2size() does not reverse sz_size2index()");
  
      assert_zu_eq(size_class, sz_s2u(sz_index2size(index - 1) + 1),
                   "sz_s2u() does not round up to size class");
      assert_zu_eq(size_class, sz_s2u(size_class - 1),
                   "sz_s2u() does not round up to size class");
      assert_zu_eq(size_class, sz_s2u(size_class),
                   "sz_s2u() does not compute same size class");
  }
  TEST_END
  
  TEST_BEGIN(test_psize_classes)
  {
      size_t size_class, max_psz;
      pszind_t pind, max_pind;
  
      max_psz = get_max_size_class() + PAGE;
      max_pind = sz_psz2ind(max_psz);
  
      for (pind = 0, size_class = sz_pind2sz(pind);
           pind < max_pind || size_class < max_psz;
           pind++, size_class = sz_pind2sz(pind)) {
          assert_true(pind < max_pind,
                      "Loop conditionals should be equivalent; pind=%u, "
                      "size_class=%zu (%#zx)",
                      pind, size_class, size_class);
          assert_true(size_class < max_psz,
                      "Loop conditionals should be equivalent; pind=%u, "
                      "size_class=%zu (%#zx)",
                      pind, size_class, size_class);
  
          assert_u_eq(pind, sz_psz2ind(size_class),
                      "sz_psz2ind() does not reverse sz_pind2sz(): pind=%u -->"
                      " size_class=%zu --> pind=%u --> size_class=%zu",
                      pind, size_class, sz_psz2ind(size_class),
                      sz_pind2sz(sz_psz2ind(size_class)));
          assert_zu_eq(size_class, sz_pind2sz(sz_psz2ind(size_class)),
                       "sz_pind2sz() does not reverse sz_psz2ind(): pind=%u -->"
                       " size_class=%zu --> pind=%u --> size_class=%zu",
                       pind, size_class, sz_psz2ind(size_class),
                       sz_pind2sz(sz_psz2ind(size_class)));
  
          if (size_class == SC_LARGE_MAXCLASS) {
              assert_u_eq(SC_NPSIZES, sz_psz2ind(size_class + 1),
                          "Next size_class does not round up properly");
          } else {
              assert_u_eq(pind + 1, sz_psz2ind(size_class + 1),
                          "Next size_class does not round up properly");
          }
  
          assert_zu_eq(size_class,
                       (pind > 0) ? sz_psz2u(sz_pind2sz(pind - 1) + 1) :
                                    sz_psz2u(1),
                       "sz_psz2u() does not round up to size class");
          assert_zu_eq(size_class, sz_psz2u(size_class - 1),
                       "sz_psz2u() does not round up to size class");
          assert_zu_eq(size_class, sz_psz2u(size_class),
                       "sz_psz2u() does not compute same size class");
          assert_zu_eq(sz_psz2u(size_class + 1), sz_pind2sz(pind + 1),
                       "sz_psz2u() does not round up to next size class");
      }
  
      assert_u_eq(pind, sz_psz2ind(sz_pind2sz(pind)),
                  "sz_psz2ind() does not reverse sz_pind2sz()");
      assert_zu_eq(max_psz, sz_pind2sz(sz_psz2ind(max_psz)),
                   "sz_pind2sz() does not reverse sz_psz2ind()");
  
      assert_zu_eq(size_class, sz_psz2u(sz_pind2sz(pind - 1) + 1),
                   "sz_psz2u() does not round up to size class");
      assert_zu_eq(size_class, sz_psz2u(size_class - 1),
                   "sz_psz2u() does not round up to size class");
      assert_zu_eq(size_class, sz_psz2u(size_class),
                   "sz_psz2u() does not compute same size class");
  }
  TEST_END
  
  TEST_BEGIN(test_overflow)
  {
      size_t max_size_class, max_psz;
  
      max_size_class = get_max_size_class();
      max_psz = max_size_class + PAGE;
  
      assert_u_eq(sz_size2index(max_size_class + 1), SC_NSIZES,
                  "sz_size2index() should return NSIZES on overflow");
      assert_u_eq(sz_size2index(ZU(PTRDIFF_MAX) + 1), SC_NSIZES,
                  "sz_size2index() should return NSIZES on overflow");
      assert_u_eq(sz_size2index(SIZE_T_MAX), SC_NSIZES,
                  "sz_size2index() should return NSIZES on overflow");
  
      assert_zu_eq(sz_s2u(max_size_class + 1), 0,
                   "sz_s2u() should return 0 for unsupported size");
      assert_zu_eq(sz_s2u(ZU(PTRDIFF_MAX) + 1), 0,
                   "sz_s2u() should return 0 for unsupported size");
      assert_zu_eq(sz_s2u(SIZE_T_MAX), 0, "sz_s2u() should return 0 on overflow");
  
      assert_u_eq(sz_psz2ind(max_size_class + 1), SC_NPSIZES,
                  "sz_psz2ind() should return NPSIZES on overflow");
      assert_u_eq(sz_psz2ind(ZU(PTRDIFF_MAX) + 1), SC_NPSIZES,
                  "sz_psz2ind() should return NPSIZES on overflow");
      assert_u_eq(sz_psz2ind(SIZE_T_MAX), SC_NPSIZES,
                  "sz_psz2ind() should return NPSIZES on overflow");
  
      assert_zu_eq(
          sz_psz2u(max_size_class + 1), max_psz,
          "sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported"
          " size");
      assert_zu_eq(
          sz_psz2u(ZU(PTRDIFF_MAX) + 1), max_psz,
          "sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported "
          "size");
      assert_zu_eq(
          sz_psz2u(SIZE_T_MAX), max_psz,
          "sz_psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow");
  }
  TEST_END
  
  int main(void)
  {
      return test(test_size_classes, test_psize_classes, test_overflow);
  }
  