fixed reader last result

src/DataAccess/ScReader.cpp

 #include "ScReader.h"
 
 thread_local LPSCARDCONTEXT ScReader::_context = nullptr;
-thread_local LONG ScReader::_lastResult = SCARD_S_SUCCESS;
+thread_local LONG ScReader::_lastStaticResult = SCARD_S_SUCCESS;
 
 ScReader::~ScReader()
 {
     if (!freeContext())
         return false;
     _context = new SCARDCONTEXT[1];
-    _lastResult = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, _context);
-    return _lastResult == SCARD_S_SUCCESS;
+    _lastStaticResult = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, _context);
+    return _lastStaticResult == SCARD_S_SUCCESS;
 }
 
 bool ScReader::freeContext()
 {
     if (!_context)
         return true;
-    _lastResult = SCardReleaseContext(*_context);
+    _lastStaticResult = SCardReleaseContext(*_context);
     delete[] _context;
     _context = nullptr;
-    return _lastResult == SCARD_S_SUCCESS;
+    return _lastStaticResult == SCARD_S_SUCCESS;
 }
 
 bool ScReader::connect(DWORD shareMode, DWORD protocols, DWORD disposition)
     std::vector<std::shared_ptr<ScReader>> readers;
     DWORD readerCount = SCARD_AUTOALLOCATE;
     LPTSTR readersNames = nullptr;
-    _lastResult = SCardListReaders(*_context, nullptr, (LPTSTR)&readersNames, &readerCount);
-    if (_lastResult == SCARD_S_SUCCESS)
+    _lastStaticResult = SCardListReaders(*_context, nullptr, (LPTSTR)&readersNames, &readerCount);
+    if (_lastStaticResult == SCARD_S_SUCCESS)
     {
         LPTSTR reader = readersNames;
         while (*reader)
     return readers;
 }
 
+LONG ScReader::getLastStaticResult()
+{
+    return _lastStaticResult;
+}
+
 LONG ScReader::getLastResult()
 {
     return _lastResult;

src/include/ScReader.h

 
     static std::vector<std::shared_ptr<ScReader>> getReaders();
 
-    static LONG getLastResult();
+    static LONG getLastStaticResult();
+
+    LONG getLastResult();
 
     static bool establishContext();
 
 
     static thread_local LPSCARDCONTEXT _context;
 
+    static thread_local LONG _lastStaticResult;
+
     LPSCARDHANDLE _card;
 
     LPDWORD _proto;
 
     SCARD_IO_REQUEST _sendPci;
 
-    static thread_local LONG _lastResult;
+    LONG _lastResult;
 };
 
 # include "ScReader.hxx"

tests/test_pcsc_cpp_tools.cpp

     } while (0)
 
 #define TEST_byteArrayToString(STR, DATA, SIZE) \
-  EXPECT_EQ(STR, ScHex::byteArrayToString(std::string((char*)memcpy(new BYTE[SIZE], DATA, SIZE), SIZE)))
+  ASSERT_EQ(STR, ScHex::byteArrayToString(std::string((char*)memcpy(new BYTE[SIZE], DATA, SIZE), SIZE)))
 
 TEST(Hex, ByteArrayToString)
 {
 
 #define TEST_stringToByteArray(STR, DATA, SIZE) do {    \
     auto bytes = ScHex::stringToByteArray(STR);         \
-    EXPECT_EQ(SIZE, bytes.size());                   \
-    EXPECT_EQ(0, memcmp(bytes.data(), DATA, SIZE));  \
+    ASSERT_EQ(SIZE, bytes.size());                   \
+    ASSERT_EQ(0, memcmp(bytes.data(), DATA, SIZE));  \
     } while (0)
 
 TEST(Hex, StringToByteArray)
 {
     std::cout << "Ensure that at lest 1 reader is connected";
     getchar();
-    EXPECT_TRUE(ScReader::establishContext());
+    ASSERT_TRUE(ScReader::establishContext());
     auto readers = ScReader::getReaders();
-    EXPECT_GE(readers.size(), 1);
+    ASSERT_GE(readers.size(), 1);
     for (auto reader : readers)
     {
         std::cout << reader->getName() << std::endl;
     }
     auto reader = readers[0];
-    EXPECT_TRUE(reader->connect());
+    ASSERT_TRUE(reader->connect());
     auto res = reader->transmit(ScBasicCommand("94 A4 00 00 02 20 00 00"));
-    EXPECT_NE(nullptr, res->getData().data());
+    ASSERT_NE(nullptr, res->getData().data());
     auto resp = ScHex::byteArrayToString(res->getData());
     std::cout << "Response (" << res->getData().size() << "): " << resp << std::endl;
-    EXPECT_TRUE(reader->disconnect());
-    EXPECT_TRUE(ScReader::freeContext());
+    ASSERT_TRUE(reader->disconnect());
+    ASSERT_TRUE(ScReader::freeContext());
 }
 
 int main(int argc, char* argv[])