Use the override specifier (C++11) where we expect to be overriding the virtual function of a base class

practicalswift · practicalswift · commit aa95947ded93 · 2017-06-28T02:12:06.000+02:00
diff --git a/src/httprpc.cpp b/src/httprpc.cpp
@@ -47,11 +47,11 @@ class HTTPRPCTimerInterface : public RPCTimerInterface
     HTTPRPCTimerInterface(struct event_base* _base) : base(_base)
     {
     }
-    const char* Name()
+    const char* Name() override
     {
         return "HTTP";
     }
-    RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis)
+    RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis) override
     {
         return new HTTPRPCTimer(base, func, millis);
     }
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
@@ -46,7 +46,7 @@ class HTTPWorkItem : public HTTPClosure
         req(std::move(_req)), path(_path), func(_func)
     {
     }
-    void operator()()
+    void operator()() override
     {
         func(req.get(), path);
     }
diff --git a/src/keystore.h b/src/keystore.h
@@ -60,9 +60,9 @@ class CBasicKeyStore : public CKeyStore
     WatchOnlySet setWatchOnly;
 
 public:
-    bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);
-    bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const;
-    bool HaveKey(const CKeyID &address) const
+    bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey) override;
+    bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const override;
+    bool HaveKey(const CKeyID &address) const override
     {
         bool result;
         {
@@ -71,7 +71,7 @@ class CBasicKeyStore : public CKeyStore
         }
         return result;
     }
-    void GetKeys(std::set<CKeyID> &setAddress) const
+    void GetKeys(std::set<CKeyID> &setAddress) const override
     {
         setAddress.clear();
         {
@@ -84,7 +84,7 @@ class CBasicKeyStore : public CKeyStore
             }
         }
     }
-    bool GetKey(const CKeyID &address, CKey &keyOut) const
+    bool GetKey(const CKeyID &address, CKey &keyOut) const override
     {
         {
             LOCK(cs_KeyStore);
@@ -97,14 +97,14 @@ class CBasicKeyStore : public CKeyStore
         }
         return false;
     }
-    virtual bool AddCScript(const CScript& redeemScript);
-    virtual bool HaveCScript(const CScriptID &hash) const;
-    virtual bool GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const;
+    virtual bool AddCScript(const CScript& redeemScript) override;
+    virtual bool HaveCScript(const CScriptID &hash) const override;
+    virtual bool GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const override;
 
-    virtual bool AddWatchOnly(const CScript &dest);
-    virtual bool RemoveWatchOnly(const CScript &dest);
-    virtual bool HaveWatchOnly(const CScript &dest) const;
-    virtual bool HaveWatchOnly() const;
+    virtual bool AddWatchOnly(const CScript &dest) override;
+    virtual bool RemoveWatchOnly(const CScript &dest) override;
+    virtual bool HaveWatchOnly(const CScript &dest) const override;
+    virtual bool HaveWatchOnly() const override;
 };
 
 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKeyingMaterial;
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
@@ -160,9 +160,9 @@ class TransactionSignatureChecker : public BaseSignatureChecker
 public:
     TransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(NULL) {}
     TransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, const PrecomputedTransactionData& txdataIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(&txdataIn) {}
-    bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const;
-    bool CheckLockTime(const CScriptNum& nLockTime) const;
-    bool CheckSequence(const CScriptNum& nSequence) const;
+    bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override;
+    bool CheckLockTime(const CScriptNum& nLockTime) const override;
+    bool CheckSequence(const CScriptNum& nSequence) const override;
 };
 
 class MutableTransactionSignatureChecker : public TransactionSignatureChecker
diff --git a/src/script/sigcache.h b/src/script/sigcache.h
@@ -48,7 +48,7 @@ class CachingTransactionSignatureChecker : public TransactionSignatureChecker
 public:
     CachingTransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, bool storeIn, PrecomputedTransactionData& txdataIn) : TransactionSignatureChecker(txToIn, nInIn, amountIn, txdataIn), store(storeIn) {}
 
-    bool VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const;
+    bool VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const override;
 };
 
 void InitSignatureCache();
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
@@ -393,7 +393,7 @@ class DummySignatureChecker : public BaseSignatureChecker
 public:
     DummySignatureChecker() {}
 
-    bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const
+    bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override
     {
         return true;
     }
diff --git a/src/script/sign.h b/src/script/sign.h
@@ -40,8 +40,8 @@ class TransactionSignatureCreator : public BaseSignatureCreator {
 
 public:
     TransactionSignatureCreator(const CKeyStore* keystoreIn, const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, int nHashTypeIn=SIGHASH_ALL);
-    const BaseSignatureChecker& Checker() const { return checker; }
-    bool CreateSig(std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const;
+    const BaseSignatureChecker& Checker() const override { return checker; }
+    bool CreateSig(std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override;
 };
 
 class MutableTransactionSignatureCreator : public TransactionSignatureCreator {
@@ -55,8 +55,8 @@ class MutableTransactionSignatureCreator : public TransactionSignatureCreator {
 class DummySignatureCreator : public BaseSignatureCreator {
 public:
     DummySignatureCreator(const CKeyStore* keystoreIn) : BaseSignatureCreator(keystoreIn) {}
-    const BaseSignatureChecker& Checker() const;
-    bool CreateSig(std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const;
+    const BaseSignatureChecker& Checker() const override;
+    bool CreateSig(std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override;
 };
 
 struct SignatureData {
diff --git a/src/support/lockedpool.cpp b/src/support/lockedpool.cpp
@@ -148,9 +148,9 @@ class Win32LockedPageAllocator: public LockedPageAllocator
 {
 public:
     Win32LockedPageAllocator();
-    void* AllocateLocked(size_t len, bool *lockingSuccess);
-    void FreeLocked(void* addr, size_t len);
-    size_t GetLimit();
+    void* AllocateLocked(size_t len, bool *lockingSuccess) override;
+    void FreeLocked(void* addr, size_t len) override;
+    size_t GetLimit() override;
 private:
     size_t page_size;
 };
@@ -200,9 +200,9 @@ class PosixLockedPageAllocator: public LockedPageAllocator
 {
 public:
     PosixLockedPageAllocator();
-    void* AllocateLocked(size_t len, bool *lockingSuccess);
-    void FreeLocked(void* addr, size_t len);
-    size_t GetLimit();
+    void* AllocateLocked(size_t len, bool *lockingSuccess) override;
+    void FreeLocked(void* addr, size_t len) override;
+    size_t GetLimit() override;
 private:
     size_t page_size;
 };
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
@@ -27,7 +27,7 @@ class CAddrManTest : public CAddrMan
         insecure_rand = FastRandomContext(true);
     }
 
-    int RandomInt(int nMax)
+    int RandomInt(int nMax) override
     {
         state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();
         return (unsigned int)(state % nMax);
diff --git a/src/test/allocator_tests.cpp b/src/test/allocator_tests.cpp
@@ -131,7 +131,7 @@ class TestLockedPageAllocator: public LockedPageAllocator
 {
 public:
     TestLockedPageAllocator(int count_in, int lockedcount_in): count(count_in), lockedcount(lockedcount_in) {}
-    void* AllocateLocked(size_t len, bool *lockingSuccess)
+    void* AllocateLocked(size_t len, bool *lockingSuccess) override
     {
         *lockingSuccess = false;
         if (count > 0) {
@@ -146,10 +146,10 @@ class TestLockedPageAllocator: public LockedPageAllocator
         }
         return 0;
     }
-    void FreeLocked(void* addr, size_t len)
+    void FreeLocked(void* addr, size_t len) override
     {
     }
-    size_t GetLimit()
+    size_t GetLimit() override
     {
         return std::numeric_limits<size_t>::max();
     }
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
@@ -29,7 +29,7 @@ class CAddrManSerializationMock : public CAddrMan
 class CAddrManUncorrupted : public CAddrManSerializationMock
 {
 public:
-    void Serialize(CDataStream& s) const
+    void Serialize(CDataStream& s) const override
     {
         CAddrMan::Serialize(s);
     }
@@ -38,7 +38,7 @@ class CAddrManUncorrupted : public CAddrManSerializationMock
 class CAddrManCorrupted : public CAddrManSerializationMock
 {
 public:
-    void Serialize(CDataStream& s) const
+    void Serialize(CDataStream& s) const override
     {
         // Produces corrupt output that claims addrman has 20 addrs when it only has one addr.
         unsigned char nVersion = 1;
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
@@ -22,11 +22,11 @@ class TestConditionChecker : public AbstractThresholdConditionChecker
     mutable ThresholdConditionCache cache;
 
 public:
-    int64_t BeginTime(const Consensus::Params& params) const { return TestTime(10000); }
-    int64_t EndTime(const Consensus::Params& params) const { return TestTime(20000); }
-    int Period(const Consensus::Params& params) const { return 1000; }
-    int Threshold(const Consensus::Params& params) const { return 900; }
-    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const { return (pindex->nVersion & 0x100); }
+    int64_t BeginTime(const Consensus::Params& params) const override { return TestTime(10000); }
+    int64_t EndTime(const Consensus::Params& params) const override { return TestTime(20000); }
+    int Period(const Consensus::Params& params) const override { return 1000; }
+    int Threshold(const Consensus::Params& params) const override { return 900; }
+    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override { return (pindex->nVersion & 0x100); }
 
     ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateFor(pindexPrev, paramsDummy, cache); }
     int GetStateSinceHeightFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateSinceHeightFor(pindexPrev, paramsDummy, cache); }
diff --git a/src/txdb.h b/src/txdb.h
@@ -88,12 +88,12 @@ class CCoinsViewDBCursor: public CCoinsViewCursor
 public:
     ~CCoinsViewDBCursor() {}
 
-    bool GetKey(COutPoint &key) const;
-    bool GetValue(Coin &coin) const;
-    unsigned int GetValueSize() const;
+    bool GetKey(COutPoint &key) const override;
+    bool GetValue(Coin &coin) const override;
+    unsigned int GetValueSize() const override;
 
-    bool Valid() const;
-    void Next();
+    bool Valid() const override;
+    void Next() override;
 
 private:
     CCoinsViewDBCursor(CDBIterator* pcursorIn, const uint256 &hashBlockIn):
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -1462,12 +1462,12 @@ class WarningBitsConditionChecker : public AbstractThresholdConditionChecker
 public:
     WarningBitsConditionChecker(int bitIn) : bit(bitIn) {}
 
-    int64_t BeginTime(const Consensus::Params& params) const { return 0; }
-    int64_t EndTime(const Consensus::Params& params) const { return std::numeric_limits<int64_t>::max(); }
-    int Period(const Consensus::Params& params) const { return params.nMinerConfirmationWindow; }
-    int Threshold(const Consensus::Params& params) const { return params.nRuleChangeActivationThreshold; }
+    int64_t BeginTime(const Consensus::Params& params) const override { return 0; }
+    int64_t EndTime(const Consensus::Params& params) const override { return std::numeric_limits<int64_t>::max(); }
+    int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
+    int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
 
-    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const
+    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
     {
         return ((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) &&
                ((pindex->nVersion >> bit) & 1) != 0 &&
diff --git a/src/versionbits.cpp b/src/versionbits.cpp
@@ -174,12 +174,12 @@ class VersionBitsConditionChecker : public AbstractThresholdConditionChecker {
     const Consensus::DeploymentPos id;
 
 protected:
-    int64_t BeginTime(const Consensus::Params& params) const { return params.vDeployments[id].nStartTime; }
-    int64_t EndTime(const Consensus::Params& params) const { return params.vDeployments[id].nTimeout; }
-    int Period(const Consensus::Params& params) const { return params.nMinerConfirmationWindow; }
-    int Threshold(const Consensus::Params& params) const { return params.nRuleChangeActivationThreshold; }
+    int64_t BeginTime(const Consensus::Params& params) const override { return params.vDeployments[id].nStartTime; }
+    int64_t EndTime(const Consensus::Params& params) const override { return params.vDeployments[id].nTimeout; }
+    int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
+    int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
 
-    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const
+    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
     {
         return (((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) && (pindex->nVersion & Mask(params)) != 0);
     }
diff --git a/src/wallet/crypter.h b/src/wallet/crypter.h
@@ -157,8 +157,8 @@ class CCryptoKeyStore : public CBasicKeyStore
     bool Lock();
 
     virtual bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
-    bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);
-    bool HaveKey(const CKeyID &address) const
+    bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey) override;
+    bool HaveKey(const CKeyID &address) const override
     {
         {
             LOCK(cs_KeyStore);
@@ -168,9 +168,9 @@ class CCryptoKeyStore : public CBasicKeyStore
         }
         return false;
     }
-    bool GetKey(const CKeyID &address, CKey& keyOut) const;
-    bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const;
-    void GetKeys(std::set<CKeyID> &setAddress) const
+    bool GetKey(const CKeyID &address, CKey& keyOut) const override;
+    bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const override;
+    void GetKeys(std::set<CKeyID> &setAddress) const override
     {
         if (!IsCrypted())
         {
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -1153,7 +1153,7 @@ class CReserveKey : public CReserveScript
     void ReturnKey();
     bool GetReservedKey(CPubKey &pubkey, bool internal = false);
     void KeepKey();
-    void KeepScript() { KeepKey(); }
+    void KeepScript() override { KeepKey(); }
 };
 
 
diff --git a/src/zmq/zmqpublishnotifier.h b/src/zmq/zmqpublishnotifier.h
@@ -24,32 +24,32 @@ class CZMQAbstractPublishNotifier : public CZMQAbstractNotifier
     */
     bool SendMessage(const char *command, const void* data, size_t size);
 
-    bool Initialize(void *pcontext);
-    void Shutdown();
+    bool Initialize(void *pcontext) override;
+    void Shutdown() override;
 };
 
 class CZMQPublishHashBlockNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyBlock(const CBlockIndex *pindex);
+    bool NotifyBlock(const CBlockIndex *pindex) override;
 };
 
 class CZMQPublishHashTransactionNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyTransaction(const CTransaction &transaction);
+    bool NotifyTransaction(const CTransaction &transaction) override;
 };
 
 class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyBlock(const CBlockIndex *pindex);
+    bool NotifyBlock(const CBlockIndex *pindex) override;
 };
 
 class CZMQPublishRawTransactionNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyTransaction(const CTransaction &transaction);
+    bool NotifyTransaction(const CTransaction &transaction) override;
 };
 
 #endif // BITCOIN_ZMQ_ZMQPUBLISHNOTIFIER_H

Original file line number	Diff line number	Diff line change
`@@ -47,11 +47,11 @@ class HTTPRPCTimerInterface : public RPCTimerInterface`
`47`	`47`	`HTTPRPCTimerInterface(struct event_base* _base) : base(_base)`
`48`	`48`	`{`
`49`	`49`	`}`
`50`		`- const char* Name()`
	`50`	`+ const char* Name() override`
`51`	`51`	`{`
`52`	`52`	`return "HTTP";`
`53`	`53`	`}`
`54`		`- RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis)`
	`54`	`+ RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis) override`
`55`	`55`	`{`
`56`	`56`	`return new HTTPRPCTimer(base, func, millis);`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ class HTTPWorkItem : public HTTPClosure`
`46`	`46`	`req(std::move(_req)), path(_path), func(_func)`
`47`	`47`	`{`
`48`	`48`	`}`
`49`		`- void operator()()`
	`49`	`+ void operator()() override`
`50`	`50`	`{`
`51`	`51`	`func(req.get(), path);`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,9 +60,9 @@ class CBasicKeyStore : public CKeyStore`
`60`	`60`	`WatchOnlySet setWatchOnly;`
`61`	`61`
`62`	`62`	`public:`
`63`		`- bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);`
`64`		`- bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const;`
`65`		`- bool HaveKey(const CKeyID &address) const`
	`63`	`+ bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey) override;`
	`64`	`+ bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const override;`
	`65`	`+ bool HaveKey(const CKeyID &address) const override`
`66`	`66`	`{`
`67`	`67`	`bool result;`
`68`	`68`	`{`
`@@ -71,7 +71,7 @@ class CBasicKeyStore : public CKeyStore`
`71`	`71`	`}`
`72`	`72`	`return result;`
`73`	`73`	`}`
`74`		`- void GetKeys(std::set<CKeyID> &setAddress) const`
	`74`	`+ void GetKeys(std::set<CKeyID> &setAddress) const override`
`75`	`75`	`{`
`76`	`76`	`setAddress.clear();`
`77`	`77`	`{`
`@@ -84,7 +84,7 @@ class CBasicKeyStore : public CKeyStore`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`}`
`87`		`- bool GetKey(const CKeyID &address, CKey &keyOut) const`
	`87`	`+ bool GetKey(const CKeyID &address, CKey &keyOut) const override`
`88`	`88`	`{`
`89`	`89`	`{`
`90`	`90`	`LOCK(cs_KeyStore);`
`@@ -97,14 +97,14 @@ class CBasicKeyStore : public CKeyStore`
`97`	`97`	`}`
`98`	`98`	`return false;`
`99`	`99`	`}`
`100`		`- virtual bool AddCScript(const CScript& redeemScript);`
`101`		`- virtual bool HaveCScript(const CScriptID &hash) const;`
`102`		`- virtual bool GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const;`
	`100`	`+ virtual bool AddCScript(const CScript& redeemScript) override;`
	`101`	`+ virtual bool HaveCScript(const CScriptID &hash) const override;`
	`102`	`+ virtual bool GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const override;`
`103`	`103`
`104`		`- virtual bool AddWatchOnly(const CScript &dest);`
`105`		`- virtual bool RemoveWatchOnly(const CScript &dest);`
`106`		`- virtual bool HaveWatchOnly(const CScript &dest) const;`
`107`		`- virtual bool HaveWatchOnly() const;`
	`104`	`+ virtual bool AddWatchOnly(const CScript &dest) override;`
	`105`	`+ virtual bool RemoveWatchOnly(const CScript &dest) override;`
	`106`	`+ virtual bool HaveWatchOnly(const CScript &dest) const override;`
	`107`	`+ virtual bool HaveWatchOnly() const override;`
`108`	`108`	`};`
`109`	`109`
`110`	`110`	`typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKeyingMaterial;`
Original file line number	Diff line number	Diff line change
`@@ -393,7 +393,7 @@ class DummySignatureChecker : public BaseSignatureChecker`
`393`	`393`	`public:`
`394`	`394`	`DummySignatureChecker() {}`
`395`	`395`
`396`		`- bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const`
	`396`	`+ bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override`
`397`	`397`	`{`
`398`	`398`	`return true;`
`399`	`399`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ class CAddrManTest : public CAddrMan`
`27`	`27`	`insecure_rand = FastRandomContext(true);`
`28`	`28`	`}`
`29`	`29`
`30`		`- int RandomInt(int nMax)`
	`30`	`+ int RandomInt(int nMax) override`
`31`	`31`	`{`
`32`	`32`	`state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();`
`33`	`33`	`return (unsigned int)(state % nMax);`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ class TestLockedPageAllocator: public LockedPageAllocator`
`131`	`131`	`{`
`132`	`132`	`public:`
`133`	`133`	`TestLockedPageAllocator(int count_in, int lockedcount_in): count(count_in), lockedcount(lockedcount_in) {}`
`134`		`- void* AllocateLocked(size_t len, bool *lockingSuccess)`
	`134`	`+ void* AllocateLocked(size_t len, bool *lockingSuccess) override`
`135`	`135`	`{`
`136`	`136`	`*lockingSuccess = false;`
`137`	`137`	`if (count > 0) {`
`@@ -146,10 +146,10 @@ class TestLockedPageAllocator: public LockedPageAllocator`
`146`	`146`	`}`
`147`	`147`	`return 0;`
`148`	`148`	`}`
`149`		`- void FreeLocked(void* addr, size_t len)`
	`149`	`+ void FreeLocked(void* addr, size_t len) override`
`150`	`150`	`{`
`151`	`151`	`}`
`152`		`- size_t GetLimit()`
	`152`	`+ size_t GetLimit() override`
`153`	`153`	`{`
`154`	`154`	`return std::numeric_limits<size_t>::max();`
`155`	`155`	`}`