Quelle TestSaturate.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <mozilla/Saturate.h>

#include <mozilla/Assertions.h>

#include <limits>

using mozilla::detail::Saturate;

#define A(a) MOZ_RELEASE_ASSERT(a, "Test \'" #a "\' failed.")

static const unsigned long sNumOps = 32;

template <typename T>
static T StartValue() {
  // Specialize |StartValue| for the given type.
  A(false);
}

template <>
int8_t StartValue<int8_t>() {
  return 0;
}

template <>
int16_t StartValue<int16_t>() {
  return 0;
}

template <>
int32_t StartValue<int32_t>() {
  return 0;
}

template <>
uint8_t StartValue<uint8_t>() {
  // Picking a value near middle of uint8_t's range.
  return static_cast<uint8_t>(std::numeric_limits<int8_t>::max());
}

template <>
uint16_t StartValue<uint16_t>() {
  // Picking a value near middle of uint16_t's range.
  return static_cast<uint8_t>(std::numeric_limits<int16_t>::max());
}

template <>
uint32_t StartValue<uint32_t>() {
  // Picking a value near middle of uint32_t's range.
  return static_cast<uint8_t>(std::numeric_limits<int32_t>::max());
}

// Add
//

template <typename T>
static void TestPrefixIncr() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A(++value == ++satValue);
  }
}

template <typename T>
static void TestPostfixIncr() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A(value++ == satValue++);
  }
}

template <typename T>
static void TestAdd() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A((value + i) == (satValue + i));
  }
}

// Subtract
//

template <typename T>
static void TestPrefixDecr() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A(--value == --satValue);
  }
}

template <typename T>
static void TestPostfixDecr() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A(value-- == satValue--);
  }
}

template <typename T>
static void TestSub() {
  T value = StartValue<T>();
  Saturate<T> satValue(value);

  for (T i = 0; i < static_cast<T>(sNumOps); ++i) {
    A((value - i) == (satValue - i));
  }
}

// Corner cases near bounds
//

template <typename T>
static void TestUpperBound() {
  Saturate<T> satValue(std::numeric_limits<T>::max());

  A(--satValue == (std::numeric_limits<T>::max() - 1));
  A(++satValue == (std::numeric_limits<T>::max()));
  A(++satValue == (std::numeric_limits<T>::max()));      // don't overflow here
  A(++satValue == (std::numeric_limits<T>::max()));      // don't overflow here
  A(--satValue == (std::numeric_limits<T>::max() - 1));  // back at (max - 1)
  A(--satValue == (std::numeric_limits<T>::max() - 2));
}

template <typename T>
static void TestLowerBound() {
  Saturate<T> satValue(std::numeric_limits<T>::min());

  A(++satValue == (std::numeric_limits<T>::min() + 1));
  A(--satValue == (std::numeric_limits<T>::min()));
  A(--satValue == (std::numeric_limits<T>::min()));      // don't overflow here
  A(--satValue == (std::numeric_limits<T>::min()));      // don't overflow here
  A(++satValue == (std::numeric_limits<T>::min() + 1));  // back at (max + 1)
  A(++satValue == (std::numeric_limits<T>::min() + 2));
}

// Framework
//

template <typename T>
static void TestAll() {
  // Assert that we don't accidently hit type's range limits in tests.
  const T value = StartValue<T>();
  A(std::numeric_limits<T>::min() + static_cast<T>(sNumOps) <= value);
  A(std::numeric_limits<T>::max() - static_cast<T>(sNumOps) >= value);

  TestPrefixIncr<T>();
  TestPostfixIncr<T>();
  TestAdd<T>();

  TestPrefixDecr<T>();
  TestPostfixDecr<T>();
  TestSub<T>();

  TestUpperBound<T>();
  TestLowerBound<T>();
}

int main() {
  TestAll<int8_t>();
  TestAll<int16_t>();
  TestAll<int32_t>();
  TestAll<uint8_t>();
  TestAll<uint16_t>();
  TestAll<uint32_t>();
  return 0;
}

quality85%

¤ Dauer der Verarbeitung: 0.15 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.