text: // Copyright (c) 2015-2018 The Bitcoin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include <chain.h>
  #include <chainparams.h>
  #include <pow.h>
  #include <random.h>
  #include <util/system.h>
  #include <test/test_konjocoin.h>
  
  #include <boost/test/unit_test.hpp>
  
  BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
  
  /* Test calculation of next difficulty target with no constraints applying */
  BOOST_AUTO_TEST_CASE(get_next_work)
  {
      const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
      int64_t nLastRetargetTime = 1358118740; // Block #278207
      CBlockIndex pindexLast;
      pindexLast.nHeight = 280223;
      pindexLast.nTime = 1358378777;  // Block #280223
      pindexLast.nBits = 0x1c0ac141;
      BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1c093f8dU);
  }
  
  /* Test the constraint on the upper bound for next work */
  BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
  {
      const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
      int64_t nLastRetargetTime = 1317972665; // Block #0
      CBlockIndex pindexLast;
      pindexLast.nHeight = 2015;
      pindexLast.nTime = 1318480354;  // Block #2015
      pindexLast.nBits = 0x1e0ffff0;
      BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1e0fffffU);
  }
  
  /* Test the constraint on the lower bound for actual time taken */
  BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
  {
      const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
      int64_t nLastRetargetTime = 1401682934; // NOTE: Not an actual block time
      CBlockIndex pindexLast;
      pindexLast.nHeight = 578591;
      pindexLast.nTime = 1401757934;  // Block #578591
      pindexLast.nBits = 0x1b075cf1;
      BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1b01d73cU);
  }
  
  /* Test the constraint on the upper bound for actual time taken */
  BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
  {
      const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
      int64_t nLastRetargetTime = 1463690315; // NOTE: Not an actual block time
      CBlockIndex pindexLast;
      pindexLast.nHeight = 1001951;
      pindexLast.nTime = 1464900315;  // Block #46367
      pindexLast.nBits = 0x1b015318;
      BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1b054c60U);
  }
  
  BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
  {
      const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
      std::vector<CBlockIndex> blocks(10000);
      for (int i = 0; i < 10000; i++) {
          blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
          blocks[i].nHeight = i;
          blocks[i].nTime = 1269211443 + i * chainParams->GetConsensus().nPowTargetSpacing;
          blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
          blocks[i].nChainWork = i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i - 1]) : arith_uint256(0);
      }
  
      for (int j = 0; j < 1000; j++) {
          CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
          CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
          CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
  
          int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, chainParams->GetConsensus());
          BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
      }
  }
  
  BOOST_AUTO_TEST_SUITE_END()
  